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--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--v*` convention the other SDKs follow. It cannot be + avoided; see ("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 8757a5bf70..75ee0cb187 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -362,6 +362,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 @@ -666,6 +688,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: @@ -808,6 +890,29 @@ jobs: working-directory: sdks/ts run: pnpm install --frozen-lockfile + - name: Setup Go + if: matrix.chunk.needs-go + uses: actions/setup-go@v5 + with: + # Stock Go, tracking the SDK's pinned version; componentize-go is a + # pinned `go tool` that fetches its own toolchain (cached below). + go-version-file: sdks/go/golem/go.mod + cache-dependency-path: sdks/go/golem/go.sum + + - name: Cache componentize-go toolchain + if: matrix.chunk.needs-go + uses: actions/cache@v5 + with: + # componentize-go downloads a patched Go toolchain here on first build. + path: ~/.cache/componentize-go + key: componentize-go-${{ runner.os }}-${{ hashFiles('sdks/go/golem/go.sum') }} + restore-keys: | + componentize-go-${{ runner.os }}- + + - name: Install wasm-tools for Go components + if: matrix.chunk.needs-go + run: cargo binstall --force --locked wasm-tools@1.248.0 + - name: Remove any pre-existing WASMs run: find test-components -maxdepth 1 -name '*.wasm' -delete diff --git a/Cargo.lock b/Cargo.lock index cd72f24147..8534fca8cd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3766,6 +3766,7 @@ dependencies = [ "tracing-log", "tracing-subscriber", "tree-sitter", + "tree-sitter-go", "tree-sitter-json", "tree-sitter-rust", "tree-sitter-typescript", @@ -10908,6 +10909,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 094a8776da..2306e2d494 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -277,6 +277,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 cc95794396..45bbf1683c 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}):" @@ -417,6 +418,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 25e1d9eee9..eba5d1b9b0 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 d4a029f14f..22be34796b 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..52e9678d0e --- /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::language::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> { + 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 21385ff995..74c71a0303 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 0ad4b469c3..b819cca381 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..f4c9c431ce 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,76 @@ 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 { + 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 b1ac818f93..fee967d2dd 100644 --- a/cli/golem-cli/src/app/build/gen_bridge.rs +++ b/cli/golem-cli/src/app/build/gen_bridge.rs @@ -885,6 +885,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)?; @@ -1044,8 +1050,16 @@ mod tests { } #[test] - fn validate_supported_bridge_targets_accepts_guest_targets_for_all_current_languages() { + fn validate_supported_bridge_targets_accepts_supported_guest_targets() { for language in GuestLanguage::iter() { + // Only languages whose guest agent and tool bridges are both supported + // should validate (e.g. Go has no bridge generation yet). + if !(BridgeSdkTargetKind::Agent.supports(BridgeMode::Guest, language) + && BridgeSdkTargetKind::Tool.supports(BridgeMode::Guest, language)) + { + continue; + } + let agent_target = bridge_sdk_target_with_mode( "AlphaAgent", language, @@ -1069,6 +1083,14 @@ mod tests { #[test] fn bridge_sdk_support_matrix_matches_current_capabilities() { + // Bridge generation exists for these languages; Go has none yet + // (no src/bridge_gen/go), so it is unsupported for every kind and mode. + let bridge_languages = [ + GuestLanguage::TypeScript, + GuestLanguage::Rust, + GuestLanguage::Scala, + GuestLanguage::MoonBit, + ]; let capabilities = [ (BridgeSdkTargetKind::Agent, BridgeMode::External, true), (BridgeSdkTargetKind::Agent, BridgeMode::Guest, true), @@ -1078,6 +1100,7 @@ mod tests { for (kind, mode, expected) in capabilities { for language in GuestLanguage::iter() { + let expected = expected && bridge_languages.contains(&language); assert_eq!( kind.supports(mode, language), expected, @@ -1106,7 +1129,7 @@ mod tests { } #[test] - fn dependency_guest_bridge_support_accepts_all_current_languages_for_agents_and_tools() { + fn dependency_guest_bridge_support_matches_matrix_for_agents_and_tools() { let component_name = ComponentName("component".to_string()); let agent_dependency = ComponentDependency::Agent { component_name: component_name.clone(), @@ -1117,25 +1140,29 @@ mod tests { tool_name: ToolName::try_from("tool").unwrap(), }; + // The dependency helper maps each dependency kind to its bridge target kind, + // so its answer must track BridgeSdkTargetKind::supports for every language. for language in GuestLanguage::iter() { - assert!(supported_dependency_guest_bridge_target_language( - &agent_dependency, - language - )); - assert!(supported_dependency_guest_bridge_target_language( - &tool_dependency, - language - )); + assert_eq!( + supported_dependency_guest_bridge_target_language(&agent_dependency, language), + BridgeSdkTargetKind::Agent.supports(BridgeMode::Guest, language), + ); + assert_eq!( + supported_dependency_guest_bridge_target_language(&tool_dependency, language), + BridgeSdkTargetKind::Tool.supports(BridgeMode::Guest, language), + ); } } #[test] - fn tool_guest_bridge_supported_language_names_match_all_current_languages() { + fn tool_guest_bridge_supported_language_names_match_supported_languages() { + let expected = GuestLanguage::iter() + .filter(|language| BridgeSdkTargetKind::Tool.supports(BridgeMode::Guest, *language)) + .map(|language| language.to_string()) + .join(", "); assert_eq!( BridgeSdkTargetKind::Tool.supported_language_names(BridgeMode::Guest), - GuestLanguage::iter() - .map(|language| language.to_string()) - .join(", ") + expected ); } 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 006f70e02a..6e42500182 100644 --- a/cli/golem-cli/src/app/build/task_result_marker.rs +++ b/cli/golem-cli/src/app/build/task_result_marker.rs @@ -125,6 +125,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> { + Ok(Some(format!( + "go-mod-deps:{}", + self.go_module_root.display() + ))) + } + + fn source(&self) -> anyhow::Result { + 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..e463a896cc --- /dev/null +++ b/cli/golem-cli/src/app/edit/go_mod.rs @@ -0,0 +1,235 @@ +// 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 => ` 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 => `; +/// - 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 = 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 ` (single) or +/// ` ` 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 ` + 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: ` ` + 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 => ` directive. +/// Replace *blocks* are also handled: an entry ` => ` inside a +/// `replace (…)` block is updated or removed. +fn set_replace_directive(lines: &mut Vec, 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 + && !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..43613980b6 --- /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 { + 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 = BTreeMap::new(); + collect_import_specs(current, ¤t_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(¤t_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(¤t[..start]); + output.push_str(&block); + output.push_str(¤t[end..]); + Ok(output) +} + +fn parse_go(source: &str) -> anyhow::Result { + 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) { + 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" + && 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 10c0049d8a..ca42a95691 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::language::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( Transform::ManifestHints, Transform::ApplicationName, Transform::MoonBitSdk, + Transform::GoSdk, ] } (true, "package.json") => vec![Transform::TsSdk], @@ -310,6 +312,7 @@ fn generate_directory( ] } (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, ) -> anyhow::Result { 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 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 63267eaac5..fefbb106dc 100644 --- a/cli/golem-cli/src/command_handler/app/template.rs +++ b/cli/golem-cli/src/command_handler/app/template.rs @@ -57,6 +57,19 @@ struct ExistingComponent { pub manifest_source_dir: PathBuf, // source of the manifest, where the component is defined } +/// Directory a single/first component of the given language occupies before it is +/// promoted to the multi-component layout. Go seals its whole module in a `module/` +/// directory (its `go.mod` cannot sit at the application root without the module +/// enclosing `golem-temp/` and the app manifest); every other language sits flat at +/// the application root ("."). On promotion this directory is moved/renamed to the +/// component's name like any other component. +fn single_component_dir(language: GuestLanguage) -> PathBuf { + match language { + GuestLanguage::Go => PathBuf::from("module"), + _ => PathBuf::from("."), + } +} + #[derive(Debug)] struct NewCommandContext { pub application_name_candidate: String, @@ -531,6 +544,15 @@ impl TemplateHandler { .cloned() .collect::>(); + // Language of each component being added, so a brand-new single component can + // get its language's flat directory (Go → `module`, others → "."). + let component_languages: BTreeMap = template_to_component + .iter() + .map(|(template_name, component_name)| { + (component_name.clone(), template_name.language()) + }) + .collect(); + let all_component_directories = if all_component_names.len() == 1 { let mut all_component_directories = BTreeMap::new(); @@ -541,8 +563,12 @@ impl TemplateHandler { .insert(component_name.clone(), component.dir.clone()); } None => { - all_component_directories - .insert(component_name.clone(), PathBuf::from(".")); + let dir = component_languages + .get(component_name) + .copied() + .map(single_component_dir) + .unwrap_or_else(|| PathBuf::from(".")); + all_component_directories.insert(component_name.clone(), dir); } } } @@ -575,13 +601,31 @@ impl TemplateHandler { match existing_components.get(component_name) { Some(component) => { - if component.component_dir != application_path { + // A component in its language's flat/default location gets + // promoted (moved into a named directory); one already in a + // named subdir is left as-is. For Go the flat location is the + // `module/` wrapper, not the application root. + let flat_rel = single_component_dir(component.language); + let flat_component_dir = if flat_rel == Path::new(".") { + application_path.to_path_buf() + } else { + application_path.join(&flat_rel) + }; + if component.component_dir != flat_component_dir { all_component_directories .insert(component_name.clone(), component.dir.clone()); continue; } - if component.manifest_source_dir != component.component_dir { + // Standard layout: the component's code sits at its manifest's + // dir (non-Go) or that dir's `module/` (Go). Anything else is a + // custom layout we won't auto-promote. + let expected_component_dir = if flat_rel == Path::new(".") { + component.manifest_source_dir.clone() + } else { + component.manifest_source_dir.join(&flat_rel) + }; + if component.component_dir != expected_component_dir { bail!( "Cannot add template(s), the current application uses a custom layout." ) @@ -820,6 +864,17 @@ impl TemplateHandler { }, }); } + GuestLanguage::Go => { + // A Go component is its whole module sealed in one directory (the + // `module/` wrapper for a single component). Promotion is a single + // whole-directory move: it relocates go.mod/go.sum and every package + // (agents/, internal/, any user package) in one step. golem-temp lives + // at the app root, outside the module, so it is untouched. + upgrade_plan.add(MultiComponentLayoutUpgradePlanStep::Move { + source: component.component_dir.clone(), + target: application_path.join(new_component_dir), + }); + } 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 220627c2fd..b4caa05fc6 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 9dd3346ae4..068e272635 100644 --- a/cli/golem-cli/src/model/app.rs +++ b/cli/golem-cli/src/model/app.rs @@ -393,6 +393,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, } } diff --git a/cli/golem-cli/src/model/app_raw.rs b/cli/golem-cli/src/model/app_raw.rs index ba55636abd..fc6c4e8159 100644 --- a/cli/golem-cli/src/model/app_raw.rs +++ b/cli/golem-cli/src/model/app_raw.rs @@ -1301,6 +1301,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 3edf2c162a..5d4115c5b4 100644 --- a/cli/golem-cli/src/model/deploy.rs +++ b/cli/golem-cli/src/model/deploy.rs @@ -422,6 +422,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/language.rs b/cli/golem-cli/src/model/language.rs index 354beec20c..faf78f318a 100644 --- a/cli/golem-cli/src/model/language.rs +++ b/cli/golem-cli/src/model/language.rs @@ -41,6 +41,8 @@ pub enum GuestLanguage { Rust, Scala, MoonBit, + #[value(alias = "golang")] + Go, } impl GuestLanguage { @@ -50,6 +52,7 @@ impl GuestLanguage { "ts" | "typescript" => Some(GuestLanguage::TypeScript), "scala" => Some(GuestLanguage::Scala), "moonbit" => Some(GuestLanguage::MoonBit), + "go" | "golang" => Some(GuestLanguage::Go), _ => None, } } @@ -60,6 +63,7 @@ impl GuestLanguage { "ts" => Some(GuestLanguage::TypeScript), "scala" => Some(GuestLanguage::Scala), "moonbit" => Some(GuestLanguage::MoonBit), + "go" => Some(GuestLanguage::Go), _ => None, } } @@ -70,6 +74,7 @@ impl GuestLanguage { GuestLanguage::TypeScript => "ts", GuestLanguage::Scala => "scala", GuestLanguage::MoonBit => "moonbit", + GuestLanguage::Go => "go", } } @@ -79,6 +84,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, pub moonbit_sdk_path: Option, pub moonbit_sdk_version: Option, + pub go_sdk_path: Option, + pub go_sdk_version: Option, } #[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 cbb9f30871..90c65fb658 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..331aa49358 --- /dev/null +++ b/cli/golem-cli/templates/go/common/AGENTS.md @@ -0,0 +1,241 @@ + + + +# 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 | +| `golem-add-agent-go` | Adding a new Go agent to a Golem component | +| `golem-annotate-agent-go` | Configuring an agent's definition — name, description, mode, HTTP mount, method descriptions | +| `golem-multi-instance-agent-go` | Addressing multiple instances of an agent by identity (and phantoms) | +| `golem-stateless-agent-go` | Creating ephemeral (stateless) agents | +| `golem-configure-durability-go` | Choosing durable vs ephemeral agents, and adding periodic snapshots | +| `golem-custom-snapshot-go` | Snapshot-based recovery and customizing state save/load | +| `golem-call-another-agent-go` | Calling one agent from another via typed RPC | +| `golem-fire-and-forget-go` | Fire-and-forget agent invocations with `Trigger` | +| `golem-parallel-workers-go` | Fanning out work to parallel agents and collecting results | +| `golem-recurring-task-go` | Recurring / scheduled work (self-rescheduling via `Schedule`) | +| `golem-schedule-future-call-go` | Scheduling a one-off future call from code, and canceling it | +| `golem-wait-for-external-input-go` | Waiting for external input using Golem promises | +| `golem-call-from-external-go` | Invoking agents from outside the platform (CLI, HTTP, worker REST API) | +| `golem-add-http-endpoint-go` | Exposing an agent's methods over HTTP | +| `golem-http-params-go` | Mapping HTTP path/query/header/body to method inputs | +| `golem-add-http-auth-go` | Requiring authentication on HTTP endpoints | +| `golem-add-cors-go` | Configuring CORS on HTTP endpoints | +| `golem-add-webhook-go` | Receiving external webhook callbacks | +| `golem-make-http-request-go` | Making outgoing HTTP requests via `net/http` | +| `golem-mark-read-only-go` | Marking methods read-only (side-effect-free) with result caching | +| `golem-atomic-block-go` | Atomic regions, custom durability (`DurableOp`), idempotence, oplog commit, idempotency keys | +| `golem-retry-policies-go` | Configuring semantic retry policies | +| `golem-add-transactions-go` | Saga-pattern transactions with compensation | +| `golem-add-postgres-go` | Using PostgreSQL via the `golem/rdbms/postgres` wrapper | +| `golem-add-mysql-go` | Using MySQL via the `golem/rdbms/mysql` wrapper | +| `golem-add-config-go` | Adding typed configuration (`DefineConfiguredAgent` + `golem.Config`) | +| `golem-add-secret-go` | Adding typed secrets (`golem.Secret[T]`) | +| `golem-file-io-go` | Reading and writing files with the standard `os`/`io` packages | +| `golem-logging-go` | Structured logging via `log/slog` | +| `golem-enable-otlp-go` | Enabling the OpenTelemetry (OTLP) exporter plugin | +| `golem-invoke-agent-go` | Invoking an agent method from the CLI and waiting for the result | +| `golem-trigger-agent-go` | Triggering a fire-and-forget invocation from the CLI | +| `golem-schedule-agent-go` | Scheduling a future invocation from the CLI | +| `golem-create-agent-instance-go` | Creating an agent instance with `golem agent new` | +| `golem-interactive-repl-go` | Interactive testing/scripting of agents via the REPL | +| `golem-add-go-module` | Adding a Go module dependency | + +# 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 state-free **definition** (`golem.DefineAgent` + `golem.DefineMethod` descriptors) plus an **implementation** (`golem.Implement` + `golem.Handle`), split across a `` / `impl` package pair +- **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 the `golem-call-another-agent-go` skill) +- An agent is created implicitly on first invocation — no separate creation step needed +- **Async handles cannot outlive invocations** — every async host resource (e.g. an outgoing-HTTP response or an RPC `*golem.Future`) must be consumed within the same invocation; do not store an unresolved response or future in agent state to consume it 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`, `wasi:blobstore`, `wasi:keyvalue` +- **Panics** escaping an agent method (e.g. from `golem.Must` on an unexpected error) — 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 + +A single-component app keeps the whole Go module in a `module/` directory: + +``` +golem.yaml # Application manifest +module/ # This component — its own Go module (golem.yaml dir: "module") + go.mod # pins the SDK and componentize-go + main.go # package main — blank-imports the SDK + each agent's impl package + agents/ # one folder per agent + counter/ # the counter agent + counter.go # package counter — DEFINITION: DefineAgent + method descriptors + types + impl/ + impl.go # package impl — IMPLEMENTATION: golem.Implement (registers on import) + internal/ # (optional) any non-agent packages +golem-temp/ # Build artifacts (gitignored) +``` + +The Go module lives in its own directory rather than at the app root, so the module — `go.mod` plus all +your packages — stays sealed away from the application's `golem.yaml` and the `golem-temp/` build output +(a `go.mod` at the app root would otherwise enclose them). The directory name never appears in import +paths (`go.mod` is the module root), so imports stay clean: `/agents/counter`. + +Adding a **second** component promotes the app to the multi-component layout: `module/` is renamed to its +component name and each further component gets its own directory (each still its own Go module): + +``` +golem.yaml +/ # was module/, renamed on promotion + go.mod main.go agents/ ... +/ + go.mod main.go agents/ ... +golem-temp/ +``` + +Within a component, each agent lives in `agents//`, split across two packages: a state-free +**definition** (`package `, e.g. `counter`) holding the identity, method descriptors, and +input/output types; and an **implementation** in the nested `impl/` subpackage holding the private state +and the handlers. This split is what lets agents call one another without a Go import cycle — a caller +imports only the callee's definition package (`/agents/ledger`, used as `ledger.Agent`, +`ledger.Record`), never its implementation. `main.go` (`package main`) blank-imports the SDK and each +agent's **impl** package so their registration runs on import — the same blank-import-for-side-effects +pattern Go uses for database drivers (`import _ "..."`). Adding an agent means adding an `agents//` +folder (a def file + an `impl/` subpackage) and a blank import to `main.go`. Non-agent packages can live +anywhere in the module (e.g. an `internal/` directory). + +## 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`. 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** in the definition package: the same value drives + the schema, the implementation binding and cross-agent calls. +- State is **private to the implementation package** — a caller never sees it. Cross-agent calls go + through the definition: `client := ledger.Agent.Get(id)` then `ledger.Record.Call(client, in)`. + The client hangs off the definition and the call off the descriptor, because Go methods cannot + introduce type parameters. +- `main.go` (`package main`) holds an empty `func main() {}` plus a blank import of each agent's + **implementation** 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 split into a definition + implementation package, + the impls 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` and their methods with `golem.DefineMethod` (in the + definition package); behaviour is attached in the implementation package with + `impl := golem.Implement(def, init)` and then `golem.Handle(impl, method, handler)` per method (in an + `init()`). A configured agent whose constructor reads config uses `golem.ImplementConfigured` and reads + config in a method via `golem.Config(def, ctx)`. +- Handlers may be plain closures or ordinary Go methods bound with a method expression + (`golem.Handle(impl, Cart.AddItem, golem.Bind((*state).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 +golem agent update --yes +``` + +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 + 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/agents/counter/counter.go b/cli/golem-cli/templates/go/default/component-dir/agents/counter/counter.go new file mode 100644 index 0000000000..1e66ffa9c4 --- /dev/null +++ b/cli/golem-cli/templates/go/default/component-dir/agents/counter/counter.go @@ -0,0 +1,27 @@ +// Package counter is the DEFINITION of the counter agent: its identity, method +// descriptors, and input/output types. Other agents import this package to call +// the counter; the behaviour and private state live in the impl subpackage. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID holds the agent's constructor parameters, and doubles as the type-level +// identity used by typed cross-agent calls. +type ID struct{ Name string } + +// AddIn is a method's parameter list: one WIT parameter per exported field. +type AddIn struct{ By int64 } + +// Agent is the state-free definition. Mode defaults to Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Description: "A simple durable counter", +}) + +// Method descriptors are package-level vars: the same value drives the published +// schema, the implementation binding, and calls from other agents. +var ( + Increment = golem.DefineMethod[ID, golem.Unit, int64]("increment", golem.Desc("Increase the count by one")) + Add = golem.DefineMethod[ID, AddIn, int64]("add", golem.Desc("Add to the count")) + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", golem.Desc("Return the current value")) +) diff --git a/cli/golem-cli/templates/go/default/component-dir/agents/counter/impl/impl.go b/cli/golem-cli/templates/go/default/component-dir/agents/counter/impl/impl.go new file mode 100644 index 0000000000..c0170aa604 --- /dev/null +++ b/cli/golem-cli/templates/go/default/component-dir/agents/counter/impl/impl.go @@ -0,0 +1,34 @@ +// Package impl is the IMPLEMENTATION of the counter agent: its private state and +// method handlers. main.go blank-imports this package, and importing it registers +// the agent with the SDK. +package impl + +import ( + "component-name/agents/counter" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state is the agent's private, durable state — invisible to callers. +type state struct{ value int64 } + +func (s *state) current() int64 { return s.value } + +// Implement binds the constructor and returns a handle; Handle registers each +// method on it. Handlers return only their output value; signal failure by +// panicking (the SDK recovers it into an agent-error). Model expected outcomes as +// a golem.Result. +var agent = golem.Implement(counter.Agent, func(counter.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.value++ + return ctx.State.value + }) + golem.Handle(agent, counter.Add, func(ctx *golem.Context[state], in counter.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.Handle(agent, counter.Value, golem.Bind0((*state).current)) +} 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..81e10e4302 --- /dev/null +++ b/cli/golem-cli/templates/go/default/component-dir/main.go @@ -0,0 +1,3 @@ +package main + +import _ "component-name/agents/counter/impl" 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/agents/session/impl/impl.go b/cli/golem-cli/templates/go/snapshotting/component-dir/agents/session/impl/impl.go new file mode 100644 index 0000000000..274bb95893 --- /dev/null +++ b/cli/golem-cli/templates/go/snapshotting/component-dir/agents/session/impl/impl.go @@ -0,0 +1,37 @@ +// Package impl is the IMPLEMENTATION of the session agent: its private state, +// method handlers, and custom snapshot serialization. Importing it registers the +// agent. +package impl + +import ( + "component-name/agents/session" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state keeps a running total in an unexported field. Reflection cannot see +// unexported fields, so the default snapshot (JSON of exported fields) would drop +// it; implementing golem.Snapshotter below is what makes the state survive. +type state struct{ total int64 } + +// Save/Load make state a golem.Snapshotter: the returned bytes are stored +// verbatim by the host and handed back on restore, so unexported state is kept. +func (s *state) Save() ([]byte, error) { return []byte{byte(s.total)}, nil } +func (s *state) Load(b []byte) error { + if len(b) > 0 { + s.total = int64(b[0]) + } + return nil +} + +var agent = golem.Implement(session.Agent, func(session.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, session.Spend, func(ctx *golem.Context[state], in session.SpendIn) int64 { + ctx.State.total += in.Amount + return ctx.State.total + }) + golem.Handle(agent, session.Total, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.total + }) +} diff --git a/cli/golem-cli/templates/go/snapshotting/component-dir/agents/session/session.go b/cli/golem-cli/templates/go/snapshotting/component-dir/agents/session/session.go new file mode 100644 index 0000000000..15648f02ce --- /dev/null +++ b/cli/golem-cli/templates/go/snapshotting/component-dir/agents/session/session.go @@ -0,0 +1,24 @@ +// Package session is the DEFINITION of the session agent. Its behaviour, private +// state, and custom snapshot serialization live in the impl subpackage. +package session + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID identifies the session agent by its constructor parameters. +type ID struct{ User string } + +// SpendIn is the parameter list for the spend method. +type SpendIn struct{ Amount int64 } + +// Agent snapshots its state every 5 invocations instead of the default cadence. +// Mode defaults to Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "SessionAgent", + Description: "A session that snapshots its running total every few invocations", + Snapshot: golem.SnapshotEveryN(5), +}) + +var ( + Spend = golem.DefineMethod[ID, SpendIn, int64]("spend", golem.Desc("Add to the running total")) + Total = golem.DefineMethod[ID, golem.Unit, int64]("total", golem.Desc("Return the running total")) +) 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..12a3dec57c --- /dev/null +++ b/cli/golem-cli/templates/go/snapshotting/component-dir/main.go @@ -0,0 +1,3 @@ +package main + +import _ "component-name/agents/session/impl" 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 6328f993a2..cb8e8faca2 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 699c0aa1fc..f195596283 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 + ``, which collides with the record type generated from a WIT record named + `-` (golem's `queued-card-event`), producing Go that does not compile. Renames + the colliding *constant* to `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 +//! ``, which collides with the record type generated for a WIT record +//! named `-`. 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 `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 [ ...]\n\ + \n\ + Applies workarounds for wit-bindgen crates/go codegen bugs, recursively, in each\n\ + :\n\ + \n\ + 1. renames variant tag constants that collide with a struct type of the same\n\ + name to 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 `\tNameuintN = ` 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) { + let types = struct_types(src); + let mut collisions: Vec = 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::>() + .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 { + 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 { + 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> { + 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) -> 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 = 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/docs/skills/sync-skills.ts b/docs/skills/sync-skills.ts index 8cff0bf373..01fcc28916 100644 --- a/docs/skills/sync-skills.ts +++ b/docs/skills/sync-skills.ts @@ -14,6 +14,7 @@ const CATEGORIES: Record = { ts: "TypeScript", scala: "Scala", moonbit: "MoonBit", + go: "Go", } type Skill = { @@ -199,7 +200,7 @@ function parseSkillFile(raw: string, fallbackName: string): { title: string; con function humanize(slug: string): string { return slug .replace(/^golem-/, "") - .replace(/-(rust|ts|scala)$/, "") + .replace(/-(rust|ts|scala|moonbit|go)$/, "") .split("-") .map(w => w.charAt(0).toUpperCase() + w.slice(1)) .join(" ") diff --git a/docs/src/content/next/how-to-guides.mdx b/docs/src/content/next/how-to-guides.mdx index a977ec50b0..9c1549a2d4 100644 --- a/docs/src/content/next/how-to-guides.mdx +++ b/docs/src/content/next/how-to-guides.mdx @@ -10,4 +10,5 @@ Practical, step-by-step guides for building with Golem. Each guide covers a spec + diff --git a/docs/src/content/next/how-to-guides/_meta.js b/docs/src/content/next/how-to-guides/_meta.js index fdf18e5e6a..2ad89b23be 100644 --- a/docs/src/content/next/how-to-guides/_meta.js +++ b/docs/src/content/next/how-to-guides/_meta.js @@ -14,4 +14,7 @@ export default { moonbit: { title: "MoonBit", }, + go: { + title: "Go", + }, } diff --git a/docs/src/content/next/how-to-guides/common/golem-add-component.mdx b/docs/src/content/next/how-to-guides/common/golem-add-component.mdx index 214638e3ca..05d2f5b8ea 100644 --- a/docs/src/content/next/how-to-guides/common/golem-add-component.mdx +++ b/docs/src/content/next/how-to-guides/common/golem-add-component.mdx @@ -104,6 +104,8 @@ When the existing application has a single component with `dir: "."` (source fil The CLI shows the planned file moves and asks for confirmation (auto-confirmed with `--yes`). +> **Go:** a single Go component lives in a `module/` directory (`dir: "module"`), not at the app root (its `go.mod` stays sealed away from `golem.yaml`/`golem-temp`). Promotion renames that directory to the component's name (e.g. `module/` → `go-main/`) and creates a sibling directory for the new component. + ## Agent Name Conflicts Default templates all create an agent named `CounterAgent`. When adding a new component using a default template (e.g., `rust`, `ts`, `scala`), the generated agent will conflict with any existing `CounterAgent` in other components, causing deployment failures. diff --git a/docs/src/content/next/how-to-guides/common/golem-add-env-vars.mdx b/docs/src/content/next/how-to-guides/common/golem-add-env-vars.mdx index 910ed50c12..97e0c8f25a 100644 --- a/docs/src/content/next/how-to-guides/common/golem-add-env-vars.mdx +++ b/docs/src/content/next/how-to-guides/common/golem-add-env-vars.mdx @@ -180,7 +180,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/docs/src/content/next/how-to-guides/common/golem-edit-manifest.mdx b/docs/src/content/next/how-to-guides/common/golem-edit-manifest.mdx index e1b6987ec5..8e3bb53413 100644 --- a/docs/src/content/next/how-to-guides/common/golem-edit-manifest.mdx +++ b/docs/src/content/next/how-to-guides/common/golem-edit-manifest.mdx @@ -61,7 +61,7 @@ Components are keyed by `namespace:name` (e.g., `my-app:billing`). ```yaml components: my-app:billing: - dir: billing # Base directory (relative to golem.yaml). Use "." for single-component apps + dir: billing # Base directory (relative to golem.yaml). Use "." for single-component apps ("module" for Go) templates: # Parent template names (inherit build, env, plugins, files) - rust componentWasm: target/wasm32-wasip1/debug/billing.wasm # Path to built WASM @@ -92,7 +92,7 @@ components: | Field | Type | Description | |-------|------|-------------| -| `dir` | string | Base directory for resolving paths. `"."` for single-component apps | +| `dir` | string | Base directory for resolving paths. `"."` for single-component apps (Go uses `"module"`) | | `templates` | string or string[] | Parent template name(s) to inherit from | | `componentWasm` | string | Path to the built WASM component | | `outputWasm` | string | Path for the final output WASM ready for upload | diff --git a/docs/src/content/next/how-to-guides/go.mdx b/docs/src/content/next/how-to-guides/go.mdx new file mode 100644 index 0000000000..f62ed5133f --- /dev/null +++ b/docs/src/content/next/how-to-guides/go.mdx @@ -0,0 +1,44 @@ +import { Cards } from "nextra/components" + +# Go How-To Guides + +Guides specific to developing Golem agents in Go. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/src/content/next/how-to-guides/go/_meta.js b/docs/src/content/next/how-to-guides/go/_meta.js new file mode 100644 index 0000000000..2e2b1ee543 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/_meta.js @@ -0,0 +1,38 @@ +export default { + "golem-add-go-module": "Add a Go Module Dependency", + "golem-add-agent-go": "Adding a New Agent to a Go Golem Component", + "golem-add-secret-go": "Adding Secrets to a Go Agent", + "golem-add-config-go": "Adding Typed Configuration to a Go Agent", + "golem-atomic-block-go": "Atomic Regions and Durability Controls (Go)", + "golem-call-another-agent-go": "Calling Another Agent (RPC) in Go", + "golem-call-from-external-go": "Calling Go Agents from Outside Golem", + "golem-annotate-agent-go": "Configuring a Go Agent's Definition", + "golem-configure-durability-go": "Configuring Agent Durability (Go)", + "golem-add-cors-go": "Configuring CORS on Go HTTP Endpoints", + "golem-retry-policies-go": "Configuring Semantic Retry Policies (Go)", + "golem-create-agent-instance-go": "Creating a Go Golem Agent Instance with `golem agent new`", + "golem-stateless-agent-go": "Creating Ephemeral (Stateless) Agents (Go)", + "golem-custom-snapshot-go": "Custom Snapshots in Go", + "golem-enable-otlp-go": "Enabling OpenTelemetry for a Go Agent", + "golem-add-http-endpoint-go": "Exposing a Go Agent over HTTP", + "golem-file-io-go": "File I/O in a Go Agent", + "golem-fire-and-forget-go": "Fire-and-Forget Invocations in Go (`Trigger`)", + "golem-interactive-repl-go": "Golem Interactive REPL (Go)", + "golem-http-params-go": "HTTP Request and Response Parameter Mapping (Go)", + "golem-invoke-agent-go": "Invoking a Go Golem Agent with `golem agent invoke`", + "golem-logging-go": "Logging from a Go Agent", + "golem-mark-read-only-go": "Marking Agent Methods as Read-Only (Go)", + "golem-multi-instance-agent-go": "Multiple Instances of a Go Agent", + "golem-make-http-request-go": "Outgoing HTTP Requests from a Go Agent", + "golem-parallel-workers-go": "Parallel Workers — Fan-Out / Fan-In (Go)", + "golem-recurring-task-go": "Recurring & Scheduled Tasks in Go", + "golem-add-http-auth-go": "Requiring Authentication on Go HTTP Endpoints", + "golem-add-transactions-go": "Saga-Pattern Transactions (Go)", + "golem-schedule-future-call-go": "Scheduling a Future Agent Call from Go Code", + "golem-schedule-agent-go": "Scheduling a Future Agent Invocation from the CLI", + "golem-trigger-agent-go": "Triggering a Fire-and-Forget Agent Invocation", + "golem-add-mysql-go": "Using MySQL from a Go Agent", + "golem-add-postgres-go": "Using PostgreSQL from a Go Agent", + "golem-add-webhook-go": "Using Webhooks in a Go Golem Agent", + "golem-wait-for-external-input-go": "Waiting for External Input with Golem Promises (Go)", +} diff --git a/docs/src/content/next/how-to-guides/go/golem-add-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-agent-go.mdx new file mode 100644 index 0000000000..574ddf7cd2 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-agent-go.mdx @@ -0,0 +1,154 @@ +# Adding a New Agent to a Go Golem Component + +## Overview + +An **agent** is a durable, stateful unit of computation in Golem. In Go each agent is split across two packages: + +- a state-free **definition** (`package `) — the agent's identity, its method descriptors, and the input/output types. Other agents import this package to call it. +- an **implementation** (`package impl`, in a nested `impl/` subpackage) — the private state and the method handlers. Importing this package registers the agent with the SDK. + +This split lets agents call one another without a Go import cycle, and keeps state private to the implementation. + +## Steps + +1. **Create the definition** — add `agents//.go` with `package `. +2. **Declare identity + types** — an `ID` struct (its fields are the constructor parameters), plus any input/output structs. +3. **Define the agent and its methods** — `golem.DefineAgent` + one `golem.DefineMethod` descriptor per method. +4. **Create the implementation** — add `agents//impl/impl.go` with `package impl`: a private `state`, `golem.Implement`, and one `golem.Handle` per method. +5. **Wire it in** — blank-import the impl package in `main.go`. +6. **Build** — run `golem build`. + +## Definition (`agents/counter/counter.go`) + +```go +// Package counter is the DEFINITION of the counter agent. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID holds the constructor parameters, and is the type-level identity used by +// cross-agent calls. Two agents with the same ID are the same agent. +type ID struct{ Name string } + +// AddIn is a method's parameter list: one WIT parameter per exported field. +type AddIn struct{ By int64 } + +// Agent is the state-free definition. Mode defaults to Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Description: "A simple durable counter", +}) + +// Method descriptors are package-level vars: the same value drives the published +// schema, the implementation binding, and calls from other agents. +var ( + Increment = golem.DefineMethod[ID, golem.Unit, int64]("increment", golem.Desc("Increase the count by one")) + Add = golem.DefineMethod[ID, AddIn, int64]("add", golem.Desc("Add to the count")) + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", golem.Desc("Return the current value")) +) +``` + +`golem.Unit` is the empty parameter/result placeholder (a method with no input or no output). + +## Implementation (`agents/counter/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the counter agent. +package impl + +import ( + "myapp/agents/counter" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state is the agent's private, durable state — invisible to callers. +type state struct{ value int64 } + +func (s *state) current() int64 { return s.value } + +// Implement binds the constructor and returns a handle; Handle registers each +// method on it. +var agent = golem.Implement(counter.Agent, func(counter.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.value++ + return ctx.State.value + }) + golem.Handle(agent, counter.Add, func(ctx *golem.Context[state], in counter.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.Handle(agent, counter.Value, golem.Bind0((*state).current)) +} +``` + +The handler receives `*golem.Context[state]`; `ctx.State` is your `*state`. `golem.Bind0` adapts a no-input `(*state)` method into a handler; `golem.Bind` adapts a one-input method. + +## Wiring: `main.go` + +`main.go` (`package main`) blank-imports each agent's **impl** package so its registration runs on import, plus the SDK runtime: + +```go +package main + +import ( + _ "myapp/agents/counter/impl" + + _ "github.com/golemcloud/golem/sdks/go/golem" +) + +func main() {} +``` + +Adding another agent = another `agents//` folder + one more blank import here. + +## Custom Types + +Parameter and result types are Go structs; each exported field becomes one WIT field, named by lower-camel-casing the Go name (`AmountCents` → `amountCents`). + +- Use sized integers (`int64`, `uint64`, …). Bare `int`/`uint` are **rejected** — their width is platform-dependent. +- A `*T` field means `option`. A nil slice/map is an **empty** list/map, never "absent" — use `*[]T` if you must distinguish. +- Variants/enums are declared with `golem.DefineVariant` / `golem.DefineEnum`. + +## Returning Failures + +Handlers return only their output value. Signal failure two ways: + +- **Uncaught errors** — a `panic` (e.g. from `golem.Must(...)` on an unexpected error) is treated as a crash: the invocation is retried per the agent's retry policy, and if retries are exhausted the agent becomes failed. The caller does **not** see it as a normal result. +- **Domain errors** the caller should observe as a value — model them in the method's output type with `golem.Result[Ok, Err]`: + +```go +// definition +var Record = golem.DefineMethod[ID, RecordIn, golem.Result[int64, string]]("record") + +// handler +golem.Handle(agent, Record, func(ctx *golem.Context[state], in RecordIn) golem.Result[int64, string] { + if in.Amount < 0 { + return golem.Err[int64, string]("cannot record a negative amount") + } + ctx.State.total += in.Amount + return golem.Ok[int64, string](ctx.State.total) +}) +``` + +Returning `golem.Err(...)` completes the invocation successfully — the caller receives the error as a value (and can unwrap with `.MustOk()`). Panicking instead triggers a retry and can fail the whole agent. + +## Key Constraints + +- Method parameters/results are passed by value; wrap the parameter list in a struct (one field per WIT parameter). +- `ID` must be a struct; its fields are the agent identity. Agents are created implicitly on first invocation. An `ID` with no fields (`type ID struct{}`) is a **singleton** — exactly one instance of the agent. +- Invocations run **sequentially in a single thread** — no concurrency within one agent, no locks needed. +- Method descriptors must be **package-level vars** in the definition package (the same value is used by the schema, the binding, and callers). +- State lives only in the impl package (unexported) — callers never see it. +- Target is **WASM only**: no raw sockets; outgoing HTTP goes through the SDK's WASI transport (see [`golem-make-http-request-go`](/next/how-to-guides/go/golem-make-http-request-go)). + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | This agent needs to call another agent (RPC) | +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Expose this agent's methods over HTTP | +| [`golem-multi-instance-agent-go`](/next/how-to-guides/go/golem-multi-instance-agent-go) | Address many instances of an agent by ID | +| [`golem-custom-snapshot-go`](/next/how-to-guides/go/golem-custom-snapshot-go) | Customize how the agent's state is snapshotted | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-config-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-config-go.mdx new file mode 100644 index 0000000000..bd89d85e75 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-config-go.mdx @@ -0,0 +1,134 @@ +# Adding Typed Configuration to a Go Agent + +## Overview + +A Go agent's configuration is a single **config struct** attached to the agent's type. Each exported field becomes a config key; the platform provisions the values (from `golem.yaml`, env, or the CLI) and the agent reads them back at runtime as a typed struct. Config is materialized once per worker and cached, so reads on a hot method are near-free. + +Two things change versus a plain agent: + +- define with `golem.DefineConfiguredAgent[ID, Cfg]` instead of `golem.DefineAgent[ID]`, +- implement with `golem.ImplementConfigured` (its constructor receives an `*golem.InitContext[ID, state, Cfg]`), + +then read the config with `golem.Config(Agent, ctx)` inside a method, or `ctx.Config()` inside the constructor. + +## Steps + +1. **Declare the config struct** — one exported field per config key. +2. **Attach it** with `golem.DefineConfiguredAgent[ID, Cfg]` in the definition. +3. **Implement** with `golem.ImplementConfigured`; read config from the `InitContext` in the constructor. +4. **Read at method time** with `golem.Config(Agent, ctx)`. +5. **Provide values** under `agents..config` in `golem.yaml`. + +## Definition (`agents/shop/shop.go`) + +```go +// Package shop is the DEFINITION of the shop agent. +package shop + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +// Config is the agent's whole config surface. Each exported field is a config +// key; a nested struct flattens into multi-segment paths; a pointer field is +// optional; list/map fields decode as their WIT shapes. +type Config struct { + Greeting string + Tax TaxConfig // nested → paths tax.ratePct + Timezone *string // optional (read back as nil when unset) + Features []string // list + Limits map[string]int64 // map +} + +type TaxConfig struct{ RatePct int64 } + +var Agent = golem.DefineConfiguredAgent[ID, Config](golem.Spec{ + Name: "ShopAgent", + Description: "A shop whose behaviour is driven by config", +}) + +var ( + Greet = golem.DefineMethod[ID, golem.Unit, string]("greet", golem.Desc("Greeting, from config")) + Settings = golem.DefineMethod[ID, golem.Unit, []string]("settings", golem.Desc("Return the configured features")) +) +``` + +Field-name conventions match plain agent types: use sized integers (`int64`, not bare `int`), a `*T` field is `option`, and nested structs recurse. Field names are lower-camel-cased for the wire (`RatePct` → `ratePct`). + +## Implementation (`agents/shop/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the shop agent. +package impl + +import ( + "myapp/agents/shop" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ greeting string } + +// ImplementConfigured binds the constructor; its InitContext exposes Config(). +var agent = golem.ImplementConfigured(shop.Agent, + func(ctx *golem.InitContext[shop.ID, state, shop.Config]) *state { + // Constructor-time config read: seed state once from config. + return &state{greeting: ctx.Config().Greeting} + }) + +func init() { + golem.Handle(agent, shop.Greet, func(ctx *golem.Context[state], _ golem.Unit) string { + return ctx.State.greeting + }) + + golem.Handle(agent, shop.Settings, func(ctx *golem.Context[state], _ golem.Unit) []string { + cfg := golem.Config(shop.Agent, ctx) // method-time config read + return cfg.Features + }) +} +``` + +`golem.Config(shop.Agent, ctx)` returns the whole `shop.Config` value; `ctx` is the running method's `*golem.Context[state]` (requiring it means config is only readable from inside a running method). The constructor reads the same config via `ctx.Config()` on its `InitContext`. + +## Providing Values in `golem.yaml` + +Set defaults under `agents..config`. Keys are **camelCase** — they match the lower-camel-cased Go field names; nested structs are nested maps, and a `map[string]V` is a list of `[key, value]` pairs: + +```yaml +agents: + ShopAgent: + config: + greeting: "Welcome to ACME" + tax: + ratePct: 20 + features: ["fast-checkout", "gift-wrap"] + limits: [["maxItems", 100]] + # timezone is omitted → the optional *string field reads back as nil +``` + +## Overriding Config Over RPC + +When one agent calls another, the caller can override the callee's **local** (non-secret) config at client creation with `golem.WithConfig`: + +```go +client := shop.Agent.Get( + shop.ID{Name: "acme"}, + golem.WithConfig(shop.Config{Greeting: "Hi from the caller"}), +) +``` + +Only declared local keys can be overridden; secret fields are always platform-provisioned and are skipped. + +## Key Constraints + +- Config is **agent-attached and instance-bound** — read only from within that agent's own constructor or methods, never from free-floating code. +- Reading an **undeclared** key, or an unset **required** key, traps. Declare a field as a pointer (`*T`) to read an absent value back as `nil` instead of trapping. +- Config is materialized **once per worker** and cached; local fields are read on first access and reused for the worker's life. (Secret fields stay live — see [`golem-add-secret-go`](/next/how-to-guides/go/golem-add-secret-go).) +- Use `golem.DefineAgent[ID]` (no config) for agents that need none; `golem.NoConfig` is the empty config type and never needs naming. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the base agent this config attaches to | +| [`golem-add-secret-go`](/next/how-to-guides/go/golem-add-secret-go) | Add `golem.Secret[T]` fields for sensitive values | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Override a callee's config with `golem.WithConfig` over RPC | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-cors-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-cors-go.mdx new file mode 100644 index 0000000000..cd8703989f --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-cors-go.mdx @@ -0,0 +1,80 @@ +# Configuring CORS on Go HTTP Endpoints + +## Overview + +CORS allowed-origin patterns are declared on the agent **definition**: mount-wide with `Mount.CORS`, or per route with `golem.EndpointCORS`. Origins declared at both levels are **unioned** for that route. CORS is metadata only — declaring it advertises the origins the platform will allow; the gateway handles preflight automatically. + +## Steps + +1. **Set mount-level origins** with `Mount.CORS` to cover every endpoint. +2. **Add per-endpoint origins** with `golem.EndpointCORS(patterns...)`; they union with the mount list. +3. **Use `"*"`** to allow all origins. + +## Mount-level CORS + +`Mount.CORS` is a `[]string` of allowed-origin patterns applied to **all** endpoints: + +```go +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "MyAgent", + HTTP: &golem.Mount{ + Path: "/api/{name}", + CORS: []string{"https://app.example.com"}, // all endpoints + }, +}) + +// GET /api/{name}/data — allows https://app.example.com +var GetData = golem.DefineMethod[ID, golem.Unit, Data]("getData", + golem.HTTP(golem.GET("/data"))) +``` + +## Endpoint-level CORS + +`golem.EndpointCORS(patterns...)` adds origins for one route. They are **unioned** with the mount-level list, not replaced: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "MyAgent", + HTTP: &golem.Mount{Path: "/api/{name}", CORS: []string{"https://app.example.com"}}, +}) + +var ( + // Allows BOTH https://app.example.com AND * (all origins) + GetData = golem.DefineMethod[ID, golem.Unit, Data]("getData", + golem.HTTP(golem.GET("/data", golem.EndpointCORS("*")))) + + // Inherits mount-level only: https://app.example.com + GetOther = golem.DefineMethod[ID, golem.Unit, Data]("getOther", + golem.HTTP(golem.GET("/other"))) +) +``` + +## Wildcard + +Use `"*"` to allow all origins: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "PublicAgent", + HTTP: &golem.Mount{Path: "/public/{name}", CORS: []string{"*"}}, +}) +``` + +## CORS preflight + +The platform handles `OPTIONS` preflight requests automatically for endpoints that have CORS configured — you do not declare an `OPTIONS` route yourself. The preflight response carries `Access-Control-Allow-Origin`, `Access-Control-Allow-Methods`, and `Access-Control-Allow-Headers`. + +## Key Constraints + +- `Mount.CORS` and `golem.EndpointCORS(patterns...)` both take origin patterns; the effective set for a route is the **union** of the two. +- An empty `CORS` means no cross-origin access is allowed for that scope. +- CORS declared in code still requires the agent to be served behind an `httpApi` deployment (see [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go)). + +### Related Guides +| Guide | Description | +|---|---| +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Set up the mount and endpoints before adding CORS | +| [`golem-add-http-auth-go`](/next/how-to-guides/go/golem-add-http-auth-go) | Require authentication on the endpoints | +| [`golem-http-params-go`](/next/how-to-guides/go/golem-http-params-go) | Bind request path/query/header/body to method inputs | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-go-module.mdx b/docs/src/content/next/how-to-guides/go/golem-add-go-module.mdx new file mode 100644 index 0000000000..803fcba887 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-go-module.mdx @@ -0,0 +1,47 @@ +# Add a Go Module Dependency + +## Important constraints + +- The component compiles to a WebAssembly component (WASI) via `componentize-go` — only code that works on that target will build. +- Modules that use OS threads, raw sockets (`net.Dial`), most database drivers, `cgo`, or platform-specific syscalls **will not work**. +- Pure-Go modules, and modules that do I/O through the standard library the SDK adapts (e.g. HTTP via `net/http`), generally work. +- If unsure whether a module builds for WASM, add it and run `golem build` to find out. + +## Steps + +1. **Add the dependency** in the component's module directory (where its `go.mod` lives): + + ```shell + go get github.com/example/mod@latest + ``` + + Then import and use it in your code. `go get` records it in `go.mod`. + +2. **Build to verify** + + ```shell + golem build --yes + ``` + + `golem build` runs `go mod tidy` for you before compiling. Do NOT rely on a bare `go build` for the component — it can't link the WASI component; always use `golem build`. + +3. **If the build fails** + + - Look for `wasip1`/`wasm`-unsupported errors, references to `net`, `syscall`, or C dependencies — those modules are incompatible with the WASM target. + - Check whether the module offers a pure-Go or `wasm` build mode/build tag. + - Look for an alternative module that supports WASM. + +## Already available (do NOT re-add) + +- `github.com/golemcloud/golem/sdks/go/golem` — the Golem Go SDK (agents, durability, RPC, retry, config/secrets, keyvalue/blobstore/rdbms/websocket, logging). Its subpackages (`.../golem/retry`, `.../golem/keyvalue`, etc.) are part of the same module. +- `github.com/bytecodealliance/componentize-go` — pinned as a **`tool`** dependency in `go.mod` so `go tool componentize-go` runs the pinned version. Leave the `tool` directive in place; don't remove it. + +## HTTP and networking + +Use the standard `net/http` package — the SDK routes it through the durable WASI HTTP transport (see [`golem-make-http-request-go`](/next/how-to-guides/go/golem-make-http-request-go)). Raw sockets (`net.Dial`, `crypto/tls` over a custom conn) are **not** available on the WASM target. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-make-http-request-go`](/next/how-to-guides/go/golem-make-http-request-go) | Call an external service over HTTP | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Use a new dependency inside an agent | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-http-auth-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-http-auth-go.mdx new file mode 100644 index 0000000000..5a5febdaeb --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-http-auth-go.mdx @@ -0,0 +1,97 @@ +# Requiring Authentication on Go HTTP Endpoints + +## Overview + +Golem authenticates HTTP endpoints via OIDC providers. Auth is declared on the agent **definition** — mount-wide with `Mount.Auth`, or per route with `golem.EndpointAuth` — and then wired to a security scheme in the manifest's (`golem.yaml`) `httpApi` deployment. Declaring auth in code without a matching deployment configuration only advertises the requirement; serving it needs the deployment. + +## Steps + +1. **Require auth** at the mount (`Mount{Auth: true}`) or per endpoint (`golem.EndpointAuth(true)`). +2. **Override where needed** — a per-endpoint `golem.EndpointAuth(...)` beats the mount default. +3. **Configure a security scheme** in `golem.yaml` under the `httpApi` deployment. + +## Auth on all endpoints (mount level) + +Set `Auth: true` on the `Mount` to require authentication for every endpoint of the agent: + +```go +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "SecureAgent", + HTTP: &golem.Mount{Path: "/secure/{name}", Auth: true}, // all endpoints require auth +}) +``` + +## Auth on individual endpoints + +With no mount-level default, require auth on a specific route with `golem.EndpointAuth(true)`: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ApiAgent", + HTTP: &golem.Mount{Path: "/api/{name}"}, +}) + +var ( + // GET /api/{name}/public — open + Public = golem.DefineMethod[ID, golem.Unit, string]("public", + golem.HTTP(golem.GET("/public"))) + + // GET /api/{name}/private — requires auth + Private = golem.DefineMethod[ID, golem.Unit, string]("private", + golem.HTTP(golem.GET("/private", golem.EndpointAuth(true)))) +) +``` + +## Overriding the mount default + +A per-endpoint `golem.EndpointAuth` overrides the mount's `Auth`. Use `false` to open a single route on an otherwise-protected agent: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "MostlySecureAgent", + HTTP: &golem.Mount{Path: "/api/{name}", Auth: true}, // default: auth required +}) + +var ( + // GET /api/{name}/health — override to open + Health = golem.DefineMethod[ID, golem.Unit, string]("health", + golem.HTTP(golem.GET("/health", golem.EndpointAuth(false)))) + + // GET /api/{name}/data — inherits the mount default (auth required) + GetData = golem.DefineMethod[ID, golem.Unit, Data]("getData", + golem.HTTP(golem.GET("/data"))) +) +``` + +## Deployment configuration + +After declaring auth in code, configure a security scheme in `golem.yaml` under the `httpApi` deployment (this is where `subdomain` versus `domain` is chosen). Quick reference: + +```yaml +httpApi: + deployments: + local: + - subdomain: my-app # resolves to my-app.localhost:9006 by default + agents: + SecureAgent: + securityScheme: my-oidc # production OIDC + # or for development: + # SecureAgent: + # testSessionHeaderName: X-Test-Auth +``` + +## Key Constraints + +- `Mount.Auth` is a plain `bool`; `golem.EndpointAuth(required bool)` takes an explicit value (`true` to require, `false` to open). +- Setting `golem.EndpointAuth` **more than once** on one endpoint is a definition error, not a silent overwrite — set it exactly once per route. +- An endpoint with no `golem.EndpointAuth` inherits the mount's `Auth`. +- Declaring auth requires an `httpApi` deployment with a security scheme to actually enforce it — mounting alone only advertises the requirement. + +### Related Guides +| Guide | Description | +|---|---| +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Set up the mount and endpoints before adding auth | +| [`golem-add-cors-go`](/next/how-to-guides/go/golem-add-cors-go) | Allow cross-origin requests to the endpoints | +| [`golem-http-params-go`](/next/how-to-guides/go/golem-http-params-go) | Bind request path/query/header/body to method inputs | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-http-endpoint-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-http-endpoint-go.mdx new file mode 100644 index 0000000000..e8c6f23af6 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-http-endpoint-go.mdx @@ -0,0 +1,84 @@ +# Exposing a Go Agent over HTTP + +## Overview + +HTTP mounting is **metadata only**: you declare, on the agent's definition, a URL prefix for the agent and a route for each method. The platform routes matching requests to the right instance and method — there is no incoming-request handler to write in the guest. + +Two pieces, both on the **definition**: + +1. `Spec.HTTP = &golem.Mount{Path: "…"}` — the agent-level prefix. Its `{var}` segments bind the agent's constructor (`ID`) fields, so a request URL selects the instance. **Every `ID` field must appear as a `{var}`.** +2. `golem.HTTP(golem.GET("/suffix"), …)` as a method option — one or more routes per method, with request data bound to the method's input fields. + +## Steps + +1. **Add a mount** to the agent's `Spec`: `HTTP: &golem.Mount{Path: "/counters/{name}"}`. +2. **Add routes** to methods with the `golem.HTTP(...)` option and a verb constructor. +3. **Bind request data** to input fields (path `{var}`, `golem.Query`, `golem.Header`, or the JSON body). +4. **Build**, then **deploy behind an HTTP API** so the routes are served. + +## Example (definition) + +```go +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } // bound by {name} in the mount path + +type AddIn struct{ By int64 } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Description: "A counter exposed over HTTP", + // {name} binds ID.Name; CORS/Auth optional. + HTTP: &golem.Mount{Path: "/counters/{name}", CORS: []string{"*"}}, +}) + +var ( + // GET /counters/{name}/value — options compose: Desc + HTTP in one call. + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", + golem.Desc("Read the current value"), golem.HTTP(golem.GET("/value"))) + + // POST /counters/{name}/add — AddIn arrives as the JSON body + Add = golem.DefineMethod[ID, AddIn, int64]("add", + golem.Desc("Add to the count"), golem.HTTP(golem.POST("/add"))) +) +``` + +The handlers are ordinary handlers (see [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go)) — nothing HTTP-specific in the impl. + +## Binding request data to input fields + +- **Path variables** — `{sku}` in a route suffix binds the input field `Sku`: `golem.GET("/items/{sku}")`. +- **Query parameters** — `golem.Query("detailed", "detailed")` binds `?detailed=` to the `Detailed` field: + ```go + Lookup = golem.DefineMethod[ID, LookupIn, ItemInfo]("lookup", + golem.HTTP(golem.GET("/items/{sku}", golem.Query("detailed", "detailed")))) + ``` +- **Headers** — `golem.Header("X-Tenant", "tenant")` binds the header to the `Tenant` field. +- **Body** — for body-carrying verbs (`POST`/`PUT`), input fields not bound to path/query/header come from the JSON request body. + +## Auth & CORS + +- `Mount{Auth: true}` requires auth on every endpoint; `golem.EndpointAuth(true|false)` overrides it per route: + ```go + golem.HTTP(golem.GET("/items/{sku}", golem.EndpointAuth(true))) + ``` +- `Mount{CORS: []string{"*"}}` sets allowed origins for the agent; `golem.EndpointCORS(patterns...)` overrides per route. + +## Verbs + +`golem.GET`, `golem.POST`, `golem.PUT`, `golem.DELETE`, and `golem.Custom("VERB", "/path")`. `GET`/`HEAD` are bodyless — bind their inputs from path/query/header. + +## Key Constraints + +- Every `ID` field must appear as a `{var}` in `Mount.Path` (else the platform can't identify the instance); path vars may also be literals or the trailing catch-all `{*rest}`. +- A method with an HTTP endpoint but no agent-level `Spec.HTTP` mount is a definition error — set the mount. +- Serving the routes requires an HTTP API deployment (see the manifest `httpApi` configuration); mounting alone only advertises the routes. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent whose methods you're exposing | +| [`golem-make-http-request-go`](/next/how-to-guides/go/golem-make-http-request-go) | Make an *outgoing* HTTP request from agent code | +| [`golem-multi-instance-agent-go`](/next/how-to-guides/go/golem-multi-instance-agent-go) | The `{var}` path segments select an instance by ID | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-mysql-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-mysql-go.mdx new file mode 100644 index 0000000000..7fe8b0de17 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-mysql-go.mdx @@ -0,0 +1,169 @@ +# Using MySQL from a Go Agent + +## Overview + +The Go SDK ships a durable MySQL client at `github.com/golemcloud/golem/sdks/go/golem/rdbms/mysql`. It mirrors the `postgres` wrapper: open a connection with a URL, then run parametrised statements in a `database/sql`-flavoured style. Every query, execute, and commit is journaled and replayed, so the connection is durable across restarts. + +There is **no** native driver and **no** raw socket — all traffic goes through the `golem:rdbms` host, so nothing needs wiring beyond importing the subpackage. Unlike Postgres, MySQL has no recursive value families, so every value maps directly to a Go value. + +## Steps + +1. **Import** `.../golem/rdbms/mysql` in your agent's `impl` package. +2. **Open** a connection with `mysql.Open(addr)` and `defer db.Close()`. +3. **Exec / Query** with `?` placeholders; pass plain Go values or typed constructors. +4. **Scan** rows with `row.Scan(&dst…)` or the typed getters. +5. **Transactions** via `db.Transaction(func(tx *mysql.Tx) error { … })`. + +Prefer a config value or env var for the connection string over hardcoding it (see [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go)). + +## Definition (`agents/notes/notes.go`) + +```go +// Package notes is the DEFINITION of the notes agent. +package notes + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type AddIn struct { + Addr string + Body string +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "NotesAgent", Description: "Durable MySQL-backed notes", +}) + +var ( + Add = golem.DefineMethod[ID, AddIn, int64]("add", golem.Desc("Insert a note, return the new count")) + List = golem.DefineMethod[ID, golem.Unit, []string]("list", golem.Desc("Return all note bodies")) +) +``` + +## Implementation (`agents/notes/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the notes agent. +package impl + +import ( + "myapp/agents/notes" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/rdbms/mysql" +) + +type state struct{} + +var agent = golem.Implement(notes.Agent, func(notes.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, notes.Add, func(_ *golem.Context[state], in notes.AddIn) int64 { + db := golem.Must(mysql.Open(in.Addr)) // "mysql://user:pass@host:3306/app" + defer db.Close() + + golem.Must(db.Exec(`CREATE TABLE IF NOT EXISTS notes ( + id bigint AUTO_INCREMENT PRIMARY KEY, body varchar(255) NOT NULL)`)) + + // Placeholders are ?; a bare Go string maps to varchar. + golem.Must(db.Exec(`INSERT INTO notes (body) VALUES (?)`, in.Body)) + + count := golem.Must(db.Query(`SELECT count(*) FROM notes`)) + n, _ := count.Rows()[0].Int64(0) // read column 0 as int64 + return n + }) + + golem.Handle(agent, notes.List, func(_ *golem.Context[state], _ golem.Unit) []string { + db := golem.Must(mysql.Open("mysql://user:pass@localhost:3306/app")) + defer db.Close() + + rs := golem.Must(db.Query(`SELECT body FROM notes ORDER BY id`)) + var out []string + for _, r := range rs.Rows() { + var body string + golem.Must0(r.Scan(&body)) // Scan fills dsts positionally + out = append(out, body) + } + return out + }) +} +``` + +`golem.Must` unwraps `(value, error)` and panics on error (aborting the invocation, which then retries per the agent's policy); `golem.Must0` does the same for an error-only return like `Scan`. + +## Parameters and Row Getters + +Parameters are ordinary Go values — `nil`, `bool`, the signed **and unsigned** int widths, `float32`/`float64`, `string`, `[]byte`, and `time.Time` map to their natural MySQL types: + +```go +golem.Must(db.Exec( + `INSERT INTO events (id, name, qty, at) VALUES (?, ?, ?, ?)`, + int64(1), "alice", uint32(3), time.Now(), +)) +``` + +When the exact column type matters (decimal, a specific integer width, json, enum), build the parameter with a constructor from the package — each returns a `mysql.DbValue`: + +```go +golem.Must(db.Exec( + `INSERT INTO items (id, price, meta) VALUES (?, ?, ?)`, + mysql.Bigint(1), + mysql.Decimal("12.3400"), // exact decimal from string, no float rounding + mysql.JSON(`{"featured":true}`), // json from serialized text +)) +``` + +Read columns back positionally with the typed getters on `mysql.Row` — `Int64`, `Float64`, `String`, `Bool`, `Bytes`, `Time`, the generic `Get`, or `Scan`. Each returns `(value, error)`: + +```go +row := golem.Must(db.Query(`SELECT id, name, at FROM events WHERE id = ?`, int64(1))).Rows()[0] +id := golem.Must(row.Int64(0)) +name := golem.Must(row.String(1)) +at := golem.Must(row.Time(2)) +``` + +`rs.Columns()` returns the `[]mysql.Column` metadata (`Ordinal`, `Name`, `DbTypeName`). + +## Transactions + +`db.Transaction` runs a closure inside a transaction, committing if it returns `nil` and rolling back (returning the error) otherwise: + +```go +golem.Must0(db.Transaction(func(tx *mysql.Tx) error { + if _, err := tx.Exec(`UPDATE notes SET body = ? WHERE id = ?`, "updated", int64(1)); err != nil { + return err + } + return nil // returning an error here rolls back instead +})) +``` + +For manual control use `db.Begin()` then `tx.Exec` / `tx.Query` and `tx.Commit()` or `tx.Rollback()`. + +## Returning Host Errors to the Caller + +`golem.Must*` treats a host error as a crash (retry). To let the caller *observe* a failure as a value instead, keep the fallible call's `error` and model the method output as `golem.Result[Ok, Err]`: + +```go +db, err := mysql.Open(in.Addr) +if err != nil { + return golem.Err[int64, string](err.Error()) +} +``` + +## Key Constraints + +- Target is **WASM only**: no native `go-sql-driver/mysql`, no raw sockets. All SQL goes through the `golem:rdbms` host — just import `.../rdbms/mysql`. +- The connection is **durable**: every query/execute/commit is journaled and replayed. Because these are remote side effects, using the client inside a **read-only** method traps (see [`golem-mark-read-only-go`](/next/how-to-guides/go/golem-mark-read-only-go)). +- Placeholders are `?` (MySQL style). Postgres uses `$1, $2, …` — see [`golem-add-postgres-go`](/next/how-to-guides/go/golem-add-postgres-go). +- Bare `int` maps to `bigint`; use `mysql.Int(...)` for a 32-bit integer column and the `*Unsigned` constructors (or plain `uint*` values) for unsigned columns. All getters and fallible calls return `(value, error)` — pair them with `golem.Must` / `golem.Must0`. +- An unsupported plain parameter type errors at encode time with a message telling you to wrap it in a `mysql.*` constructor. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Create the agent that owns this MySQL client | +| [`golem-add-postgres-go`](/next/how-to-guides/go/golem-add-postgres-go) | Use PostgreSQL instead of (or alongside) MySQL | +| [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go) | Read the connection string from typed config | +| [`golem-add-transactions-go`](/next/how-to-guides/go/golem-add-transactions-go) | Coordinate a saga across agents (distinct from a single DB transaction) | +| [`golem-mark-read-only-go`](/next/how-to-guides/go/golem-mark-read-only-go) | Understand why DB calls trap in read-only methods | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-postgres-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-postgres-go.mdx new file mode 100644 index 0000000000..42803e0896 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-postgres-go.mdx @@ -0,0 +1,170 @@ +# Using PostgreSQL from a Go Agent + +## Overview + +The Go SDK ships a durable Postgres client at `github.com/golemcloud/golem/sdks/go/golem/rdbms/postgres`. It wraps Golem's `golem:rdbms` host in a `database/sql`-flavoured API: open a connection with a URL, then run parametrised statements and scan the rows back positionally. Every query, execute, and commit is journaled and replayed, so the connection is durable across restarts. + +There is **no** native driver and **no** raw socket — all traffic goes through the `golem:rdbms` host, so nothing needs wiring beyond importing the subpackage. + +## Steps + +1. **Import** `.../golem/rdbms/postgres` in your agent's `impl` package. +2. **Open** a connection with `postgres.Open(addr)` and `defer db.Close()`. +3. **Exec / Query** with `$1, $2, …` placeholders; pass plain Go values or typed constructors. +4. **Scan** rows with `row.Scan(&dst…)` or the typed getters. +5. **Transactions** via `db.Transaction(func(tx *postgres.Tx) error { … })`. + +Prefer a config value or env var for the connection string over hardcoding it (see [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go)). + +## Definition (`agents/notes/notes.go`) + +```go +// Package notes is the DEFINITION of the notes agent. +package notes + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type AddIn struct { + Addr string + Body string +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "NotesAgent", Description: "Durable Postgres-backed notes", +}) + +var ( + Add = golem.DefineMethod[ID, AddIn, int64]("add", golem.Desc("Insert a note, return the new count")) + List = golem.DefineMethod[ID, golem.Unit, []string]("list", golem.Desc("Return all note bodies")) +) +``` + +## Implementation (`agents/notes/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the notes agent. +package impl + +import ( + "myapp/agents/notes" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/rdbms/postgres" +) + +type state struct{} + +var agent = golem.Implement(notes.Agent, func(notes.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, notes.Add, func(_ *golem.Context[state], in notes.AddIn) int64 { + db := golem.Must(postgres.Open(in.Addr)) // "postgres://user:pass@host:5432/app" + defer db.Close() + + golem.Must(db.Exec(`CREATE TABLE IF NOT EXISTS notes ( + id bigserial PRIMARY KEY, body text NOT NULL)`)) + + // Placeholders are $1, $2, …; a bare Go string maps to text. + golem.Must(db.Exec(`INSERT INTO notes (body) VALUES ($1)`, in.Body)) + + count := golem.Must(db.Query(`SELECT count(*) FROM notes`)) + n, _ := count.Rows()[0].Int64(0) // read column 0 as int64 + return n + }) + + golem.Handle(agent, notes.List, func(_ *golem.Context[state], _ golem.Unit) []string { + db := golem.Must(postgres.Open("postgres://user:pass@localhost:5432/app")) + defer db.Close() + + rs := golem.Must(db.Query(`SELECT body FROM notes ORDER BY id`)) + var out []string + for _, r := range rs.Rows() { + var body string + golem.Must0(r.Scan(&body)) // Scan fills dsts positionally + out = append(out, body) + } + return out + }) +} +``` + +`golem.Must` unwraps `(value, error)` and panics on error (aborting the invocation, which then retries per the agent's policy); `golem.Must0` does the same for an error-only return like `Scan`. + +## Parameters and Row Getters + +Parameters are ordinary Go values — `nil`, `bool`, the sized int/float widths, `string`, `[]byte`, `uuid.UUID`, and `time.Time` map to their natural Postgres types: + +```go +golem.Must(db.Exec( + `INSERT INTO events (id, name, at, ok) VALUES ($1, $2, $3, $4)`, + int64(1), "alice", time.Now(), true, +)) +``` + +When the exact column type matters (numeric, jsonb, a specific integer width, arrays, enums, composites), build the parameter with a constructor from the package — each returns a `postgres.DbValue` you pass like any other argument: + +```go +golem.Must(db.Exec( + `INSERT INTO items (id, price, tags, meta) VALUES ($1, $2, $3, $4)`, + postgres.Int8(1), + postgres.Numeric("12.34"), // exact decimal from string, no float rounding + postgres.Array(int32(10), int32(20)), // int[] array + postgres.JSONB(`{"featured":true}`), // jsonb from serialized text +)) +``` + +Read columns back positionally with the typed getters on `postgres.Row` — `Int64`, `Float64`, `String`, `Bool`, `Bytes`, `UUID`, `Time`, the recursive `Array` / `Enum` / `Composite` / `Int4Range`, the generic `Get`, or `Scan`. Each returns `(value, error)`: + +```go +row := golem.Must(db.Query(`SELECT id, name, at FROM events WHERE id = $1`, int64(1))).Rows()[0] +id := golem.Must(row.Int64(0)) +name := golem.Must(row.String(1)) +at := golem.Must(row.Time(2)) +``` + +`rs.Columns()` returns the `[]postgres.Column` metadata (`Ordinal`, `Name`, `DbTypeName`). + +## Transactions + +`db.Transaction` runs a closure inside a transaction, committing if it returns `nil` and rolling back (returning the error) otherwise: + +```go +golem.Must0(db.Transaction(func(tx *postgres.Tx) error { + if _, err := tx.Exec(`UPDATE notes SET body = $1 WHERE id = $2`, "updated", int64(1)); err != nil { + return err + } + return nil // returning an error here rolls back instead +})) +``` + +For manual control use `db.Begin()` then `tx.Exec` / `tx.Query` and `tx.Commit()` or `tx.Rollback()`. + +## Returning Host Errors to the Caller + +`golem.Must*` treats a host error as a crash (retry). To let the caller *observe* a failure as a value instead, keep the fallible call's `error` and model the method output as `golem.Result[Ok, Err]`: + +```go +db, err := postgres.Open(in.Addr) +if err != nil { + return golem.Err[int64, string](err.Error()) +} +``` + +## Key Constraints + +- Target is **WASM only**: no native `pgx`/`lib/pq` driver, no raw sockets. All SQL goes through the `golem:rdbms` host — just import `.../rdbms/postgres`. +- The connection is **durable**: every query/execute/commit is journaled and replayed. Because these are remote side effects, using the client inside a **read-only** method traps (see [`golem-mark-read-only-go`](/next/how-to-guides/go/golem-mark-read-only-go)). +- Placeholders are `$1, $2, …` (Postgres style). MySQL uses `?` — see [`golem-add-mysql-go`](/next/how-to-guides/go/golem-add-mysql-go). +- Bare `int` maps to `int8` (bigint); use `postgres.Int4(...)` when you need a 32-bit integer column. All getters and fallible calls return `(value, error)` — pair them with `golem.Must` / `golem.Must0`. +- An unsupported plain parameter type errors at encode time with a message telling you to wrap it in a `postgres.*` constructor. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Create the agent that owns this Postgres client | +| [`golem-add-mysql-go`](/next/how-to-guides/go/golem-add-mysql-go) | Use MySQL instead of (or alongside) Postgres | +| [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go) | Read the connection string from typed config | +| [`golem-add-transactions-go`](/next/how-to-guides/go/golem-add-transactions-go) | Coordinate a saga across agents (distinct from a single DB transaction) | +| [`golem-mark-read-only-go`](/next/how-to-guides/go/golem-mark-read-only-go) | Understand why DB calls trap in read-only methods | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-secret-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-secret-go.mdx new file mode 100644 index 0000000000..4ebfa6362b --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-secret-go.mdx @@ -0,0 +1,121 @@ +# Adding Secrets to a Go Agent + +## Overview + +Secrets are sensitive configuration values (API keys, passwords, tokens) read at runtime through `golem.Secret[T]`. A secret uses the **same config mechanism as regular typed config** — it is just a field whose type is `golem.Secret[T]` inside the agent's config struct (see [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go)). The config value carries an opaque secret handle; the plaintext is revealed only when your code calls `.Get()`. + +Secrets are **not** stored in `golem.yaml` (which is source-controlled) except through `secretDefaults` for local development. In real environments they are managed per-environment via the CLI. + +## Steps + +1. **Add a `golem.Secret[T]` field** to the agent's config struct. +2. **Define / implement** the agent as a configured agent (`DefineConfiguredAgent` + `ImplementConfigured`). +3. **Reveal** the value at runtime with `.Get()`. +4. **Provide values** via `secretDefaults` (local) or the CLI (per environment). + +## Declaring a Secret Field + +A secret is any field of type `golem.Secret[T]`, at any depth of the config struct: + +```go +// Package client is the DEFINITION of an API-client agent. +package client + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type Config struct { + Endpoint string + APIKey golem.Secret[string] // a secret leaf + DB DBConfig +} + +type DBConfig struct { + Host string + Password golem.Secret[string] // secret at path db.password +} + +var Agent = golem.DefineConfiguredAgent[ID, Config](golem.Spec{ + Name: "ClientAgent", + Description: "Calls an external API using a secret key", +}) + +var Connect = golem.DefineMethod[ID, golem.Unit, string]("connect", + golem.Desc("Describe the connection using secret values")) +``` + +## Reading a Secret at Runtime + +Read the config, then call `.Get()` on the secret field to reveal the current plaintext. Because `.Get()` re-reads the host on every call, a *rotated* secret is observed rather than a stale snapshot: + +```go +// Package impl is the IMPLEMENTATION of the API-client agent. +package impl + +import ( + "fmt" + + "myapp/agents/client" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.ImplementConfigured(client.Agent, + func(_ *golem.InitContext[client.ID, state, client.Config]) *state { return &state{} }) + +func init() { + golem.Handle(agent, client.Connect, func(ctx *golem.Context[state], _ golem.Unit) string { + cfg := golem.Config(client.Agent, ctx) + + apiKey := cfg.APIKey.Get() // reveals the current plaintext + dbPass := cfg.DB.Password.Get() // secret at any depth + + return fmt.Sprintf("connecting to %s (key len=%d, db host=%s, pw len=%d)", + cfg.Endpoint, len(apiKey), cfg.DB.Host, len(dbPass)) + }) +} +``` + +A `golem.Secret[T]` cannot be constructed from a plaintext and cannot be a method parameter or return value — it is config-only, always obtained from the agent's config. Its `String()`/`GoString()` render as `golem.Secret(redacted)`, so it stays out of logs formatted with `%v`/`%s`. + +## Secret Defaults in `golem.yaml` (local only) + +For local development, set defaults under `secretDefaults.`. Keys are **camelCase** and follow the same path flattening as config; nested structs are nested maps. These are **not** used in production: + +```yaml +secretDefaults: + local: + apiKey: "dev-key-123" + db: + password: "dev-password" +``` + +## Managing Secrets via CLI (per environment) + +Outside local defaults, secrets are environment-scoped — each deployment environment has its own values, set through the platform CLI (paths use the same camelCase as the config keys): + +```shell +golem secret create apiKey --secret-type String --secret-value "sk-abc123" +golem secret create db.password --secret-type String --secret-value "s3cret" +golem secret list +golem secret update-value apiKey --secret-value "new-value" +golem secret delete apiKey +``` + +## Key Constraints + +- A secret is a **config field** of type `golem.Secret[T]` — the agent must be a configured agent (`DefineConfiguredAgent` / `ImplementConfigured`); see [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go). +- Only **`.Get()`** reveals the plaintext, and it re-reads the host each call, so a rotated value is observed without restarting the agent. Each reveal pins the resolved revision for deterministic retry/replay. +- Secret values are **never** written to `golem.yaml` except via `secretDefaults` (local dev). Production values come from the CLI, per environment. +- A missing required secret fails agent creation/deployment. Read a secret from within an invocation only — `.Get()` calls the host, and a read failure panics (surfaces as an agent error). +- Over RPC, secret fields are always platform-provisioned; `golem.WithConfig` overrides only **local** config, never secrets. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go) | The non-secret typed-config mechanism secrets build on | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the base agent the config attaches to | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Understand why secrets are not overridable over RPC | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-transactions-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-transactions-go.mdx new file mode 100644 index 0000000000..cc93e63040 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-transactions-go.mdx @@ -0,0 +1,182 @@ +# Saga-Pattern Transactions (Go) + +## Overview + +Golem supports the **saga pattern** for multi-step operations where each step has a +compensation (undo). If a later step fails, the steps that already succeeded are +compensated in **reverse order**. The saga helpers build on the durability +primitives (an atomic region + the oplog) — no persistence beyond what the runtime +already provides. + +> **Steps that call HTTP.** A transaction runs its steps inside an atomic region, +> and an outgoing HTTP request (`net/http`) does not yet settle inside one — the +> region fails to close with *"non-re-executable durable calls initiated in it are +> still in flight"*. Cross-agent RPC is unaffected, so today a step should do its +> external work through RPC to an agent that owns the HTTP call. + +The Go API lives in the `golem` package: + +- `golem.Operation[In, Out, E]` — a compensable step, built with `golem.NewOperation`. +- `golem.Step(tx, op, input)` — run an operation inside a transaction (a **free + function**, because Go methods cannot take type parameters). +- `golem.FallibleTransaction[Out, E](...)` — rolls back on failure and **returns** a + `golem.TransactionFailure[E]`. +- `golem.InfallibleTransaction[Out, E](...)` — rolls back and **retries** the whole + transaction until it succeeds. + +Expected step failures are modeled as the **error arm** of a `golem.Result` (type +`E`, often `string`). A `panic` is an infra failure: it leaves the atomic region +open so the runtime replays it. + +## Steps + +1. **Define each operation** with `golem.NewOperation(execute, compensate)`. +2. **Choose a transaction flavor** — fallible (failure is acceptable) or infallible (must eventually succeed). +3. **Run the steps** with `golem.Step(tx, op, input)` inside the transaction body. +4. **Handle the outcome** — inspect the `golem.Result` (fallible) or use the returned value (infallible). + +## Defining Operations + +An operation pairs an `execute` action with the `compensate` that undoes it. +`execute` is `func(In) golem.Result[Out, E]`; `compensate` receives **both** the +original input and the output `execute` produced, and returns +`golem.Result[golem.Unit, E]`. Compensation runs only if a later step fails. + +```go +import "github.com/golemcloud/golem/sdks/go/golem" + +// Reserve inventory; compensation cancels the reservation. E is string here. +var reserveInventory = golem.NewOperation( + func(sku string) golem.Result[string, string] { + reservationID, err := callInventoryAPI(sku) + if err != nil { + return golem.Err[string, string](err.Error()) + } + return golem.Ok[string, string](reservationID) + }, + func(sku, reservationID string) golem.Result[golem.Unit, string] { + if err := cancelReservation(reservationID); err != nil { + return golem.Err[golem.Unit, string](err.Error()) + } + return golem.Ok[golem.Unit, string](golem.Unit{}) + }, +) + +var chargePayment = golem.NewOperation( + func(amount int64) golem.Result[string, string] { + chargeID, err := callPaymentAPI(amount) + if err != nil { + return golem.Err[string, string](err.Error()) + } + return golem.Ok[string, string](chargeID) + }, + func(amount int64, chargeID string) golem.Result[golem.Unit, string] { + if err := refundPayment(chargeID); err != nil { + return golem.Err[golem.Unit, string](err.Error()) + } + return golem.Ok[golem.Unit, string](golem.Unit{}) + }, +) +``` + +## Fallible Transactions + +On a step failure, the completed steps are compensated (best-effort, in reverse) +and a `golem.TransactionFailure[E]` is returned — **there is no retry**. Run steps +with `golem.Step(tx, op, input)`; return an error result from the body to trigger +rollback. + +```go +result := golem.FallibleTransaction(func(tx *golem.Transaction[string]) golem.Result[string, string] { + r1 := golem.Step(tx, reserveInventory, "SKU-123") + if r1.IsErr() { + return golem.Err[string, string](r1.Err()) + } + r2 := golem.Step(tx, chargePayment, 4999) + if r2.IsErr() { + return golem.Err[string, string](r2.Err()) + } + // Combine the two outputs into the transaction's result value. + return golem.Ok[string, string](r1.Ok() + ":" + r2.Ok()) +}) + +if result.IsErr() { + f := result.Err() // golem.TransactionFailure[string] + _ = f.Error // the step failure that aborted the transaction + if !f.RolledBackFully() { + // A compensation itself failed — some effects may remain (needs attention). + _ = f.CompensationFailure // golem.Option[string], Some(...) here + } +} else { + orderID := result.Ok() + _ = orderID +} +``` + +`golem.TransactionFailure[E]` fields: + +- `Error E` — the step failure that aborted the transaction. +- `CompensationFailure golem.Option[E]` — `Some(...)` if a compensation itself + failed during rollback (a **partial** rollback); `None` if every compensation + succeeded. +- `RolledBackFully() bool` — true when the rollback was complete. + +## Infallible Transactions + +On a step failure, the completed steps are compensated in reverse, the oplog is +rewound to the transaction start, and the runtime **replays the whole +transaction** — so it returns the plain `Out` value, always succeeding eventually: + +```go +orderID := golem.InfallibleTransaction(func(tx *golem.Transaction[string]) golem.Result[string, string] { + r1 := golem.Step(tx, reserveInventory, "SKU-123") + if r1.IsErr() { + return golem.Err[string, string](r1.Err()) + } + r2 := golem.Step(tx, chargePayment, 4999) + if r2.IsErr() { + return golem.Err[string, string](r2.Err()) + } + return golem.Ok[string, string](r1.Ok() + ":" + r2.Ok()) +}) +// orderID is a plain string — the transaction retried until it succeeded. +``` + +Use `InfallibleTransaction` only when the steps are expected to **eventually +succeed** — a deterministic failure would retry forever. If a compensation itself +fails during a rollback-for-retry, the transaction cannot be made consistent and +the helper **panics** (surfacing which compensation failed). + +## Not available in the Go SDK + +The Rust SDK splits operations into `sync_operation` and `operation` (async), and +its transactions are `async` and require wrapping bodies in `boxed(async move { … +})`. The Go SDK has **none of that** — there is a single `golem.NewOperation`, and +transaction bodies are plain synchronous functions. Blocking work inside a step +(HTTP, RPC, promises) suspends the fiber at its await point, so no `async`/`boxed` +plumbing is needed. `golem.Step` is a top-level function (not a method on the +transaction) because Go methods cannot carry the per-step type parameters. + +## Guidelines + +- Model expected step failures as the **error arm** of the step's `golem.Result`; + reserve `panic` for infra failures (it leaves the region open for replay). +- Run every step with `golem.Step(tx, op, input)` — that is what records the + compensation to run on rollback. +- Keep compensation logic **idempotent** — it may run more than once (especially + under `InfallibleTransaction`). +- Compensation runs in **reverse** order of execution. +- All steps in one transaction share the error type `E` (commonly `string`). +- Use `FallibleTransaction` when failure is an acceptable outcome; + `InfallibleTransaction` when the operation must eventually succeed. +- A transaction opens a **worker-global** atomic region — keep the whole + transaction on one logical flow; don't run concurrent goroutines that perform + durable side effects while it is open. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-atomic-block-go`](/next/how-to-guides/go/golem-atomic-block-go) | The atomic-region / durability primitives transactions build on | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Steps that call other agents via RPC | +| [`golem-make-http-request-go`](/next/how-to-guides/go/golem-make-http-request-go) | Steps that call external HTTP APIs | +| [`golem-retry-policies-go`](/next/how-to-guides/go/golem-retry-policies-go) | Tune how failing steps/operations are retried | diff --git a/docs/src/content/next/how-to-guides/go/golem-add-webhook-go.mdx b/docs/src/content/next/how-to-guides/go/golem-add-webhook-go.mdx new file mode 100644 index 0000000000..4cfba4c2d7 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-add-webhook-go.mdx @@ -0,0 +1,138 @@ +# Using Webhooks in a Go Golem Agent + +## Overview + +A Golem webhook lets an agent mint a temporary public URL that an external system POSTs to; the POST body is delivered back to the agent. Under the hood a webhook **is a Golem promise**: the agent durably suspends while awaiting the callback, consuming no resources, and survives restarts (exactly-once via oplog replay). + +In Go there is no standalone `create_webhook` helper — you drive it through the promise API in `golem/promise.go`: + +- `golem.NewPromise[T]()` creates a promise owned by the current agent. +- `p.WebhookURL()` mints the external URL that completes that promise on POST. +- `p.ID()` returns the `golem.PromiseID` to persist in agent state. +- `golem.PromiseByID[T](id).Await()` (or `p.Await()`) suspends until the POST arrives and returns the body decoded as `T`. + +This is useful for payment gateways, CI/CD, GitHub/Stripe callbacks, and any event-driven workflow where an external system notifies the agent. + +### Prerequisites + +The agent type **must** have an HTTP mount (`Spec.HTTP = &golem.Mount{Path: "/..."}`) and be deployed via an `httpApi` deployment in `golem.yaml`. Without that, `WebhookURL()` traps (it is fail-loud). The mount does not need any HTTP endpoints — it only makes the agent HTTP-API-deployable. + +## Steps + +1. **Add an HTTP mount** to the agent's `Spec` (see [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go)). +2. **Create a promise** and mint its webhook URL; persist the `PromiseID` in state and return/share the URL. +3. **Await the callback** in a later invocation via the stored id. +4. **Deploy** behind an `httpApi` so the URL is reachable. + +## API + +| Function / method | Description | +|---|---| +| `golem.NewPromise[T]()` | Create a promise owned by the current agent; returns `*golem.Promise[T]` | +| `(*Promise[T]).WebhookURL() string` | Mint the public URL that a POST completes; requires the agent be HTTP-API-deployed | +| `(*Promise[T]).ID() golem.PromiseID` | The durable id — persist it to await/complete in a later invocation | +| `(*Promise[T]).Await() T` | Suspend until completed; returns the POST body decoded as `T` (JSON, or raw bytes when `T` is `[]byte`) | +| `golem.PromiseByID[T](id)` | Rebuild a handle from a stored `PromiseID` | +| `golem.CompletePromise[T](id, value)` | Complete a promise from *another agent* (external completers use the URL instead) | + +## Complete example + +### Definition (`agents/webhookdemo/webhookdemo.go`) + +```go +// Package webhookdemo is the DEFINITION of a webhook agent. It needs the HTTP +// mount below (plus an httpApi deployment) or WebhookURL() traps. +package webhookdemo + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Queue string } // bound by {queue} in the mount path + +// Event is the webhook payload — JSON tags are the contract for the caller's POST. +type Event struct { + OrderID string `json:"orderId"` + Amount int64 `json:"amount"` +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "WebhookDemoAgent", + Description: "Completes a promise from an external webhook POST", + HTTP: &golem.Mount{Path: "/hooks/{queue}"}, // makes the agent HTTP-API-deployable +}) + +var ( + Open = golem.DefineMethod[ID, golem.Unit, string]("open", + golem.Desc("Create a promise and return its webhook URL")) + Result = golem.DefineMethod[ID, golem.Unit, Event]("result", + golem.Desc("Await the payload POSTed to the webhook URL")) +) +``` + +### Implementation (`agents/webhookdemo/impl/impl.go`) + +```go +package impl + +import ( + "myapp/agents/webhookdemo" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct { + pending golem.PromiseID + open bool +} + +var agent = golem.Implement(webhookdemo.Agent, func(webhookdemo.ID) *state { return &state{} }) + +func init() { + // Mint a URL; persist the PromiseID so a later invocation can await it. + golem.Handle(agent, webhookdemo.Open, func(ctx *golem.Context[state], _ golem.Unit) string { + p := golem.NewPromise[webhookdemo.Event]() + ctx.State.pending = p.ID() + ctx.State.open = true + return p.WebhookURL() // hand this URL to the external system + }) + + // Suspend until the external POST arrives; returns the decoded body. + golem.Handle(agent, webhookdemo.Result, func(ctx *golem.Context[state], _ golem.Unit) webhookdemo.Event { + if !ctx.State.open { + panic("no open webhook — call open first") + } + return golem.PromiseByID[webhookdemo.Event](ctx.State.pending).Await() + }) +} +``` + +## Payload decoding + +`Await()` decodes the POST body as its type parameter `T` via JSON. Use a struct with `json` tags (as `Event` above) for structured payloads, or `golem.PromiseByID[[]byte](id).Await()` to receive the raw request bytes unchanged. + +## Webhook URL structure and suffix + +The minted URL has the shape `https://///`: + +- `` — where the HTTP API is deployed. +- `` — defaults to `/webhooks`, customizable via `webhookUrl` in the `httpApi` deployment section of `golem.yaml`. +- `` — defaults to the agent type name in kebab-case; override it with `Mount.WebhookSuffix`. +- `` — a unique per-webhook identifier. + +```go +HTTP: &golem.Mount{Path: "/api/orders/{id}", WebhookSuffix: "/workflow-hooks"}, +``` + +## Key Constraints + +- The agent **must** set `Spec.HTTP` and be deployed via `httpApi`, or `WebhookURL()` traps (it is fail-loud, surfacing an agent-error). +- Only the agent that created the promise may `Await` it; awaiting from another agent traps in the host. +- Only a `POST` to the URL completes the promise; the URL is one-shot — once completed it is invalid, and a later `Await` returns the recorded body from the oplog. +- The agent is durably suspended while awaiting — it survives failures, restarts, and updates. +- **Go difference from Rust:** `Mount.WebhookSuffix` must be **literal segments only** — path variables like `{agent-type}` or `{name}` in the suffix are rejected in the Go SDK (the Rust `webhook_suffix` allows them). + +### Related Guides +| Guide | Description | +|---|---| +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Set up the HTTP mount + `httpApi` deployment webhooks require | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent and its payload types | +| [`golem-add-http-auth-go`](/next/how-to-guides/go/golem-add-http-auth-go) | Require authentication on the agent's other endpoints | diff --git a/docs/src/content/next/how-to-guides/go/golem-annotate-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-annotate-agent-go.mdx new file mode 100644 index 0000000000..dc60282390 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-annotate-agent-go.mdx @@ -0,0 +1,125 @@ +# Configuring a Go Agent's Definition + +## Overview + +An agent's **definition** carries all of its declarative metadata. In Go there are no attribute macros — the metadata is plain values you pass to `golem.DefineAgent`: + +- the `golem.Spec` struct — `Name`, `Description`, `Mode`, `HTTP` (mount), and `Snapshot`; +- per-method options passed to `golem.DefineMethod` — `golem.Desc(...)` for a method description and `golem.HTTP(...)` for HTTP routes. + +This metadata is surfaced in the published agent-type schema (used by the platform, by other agents, and by metadata/LLM tool discovery). It has no effect on the handler logic itself. + +## Steps + +1. **Set identity + mode** on the `Spec`: `Name`, `Description`, and (optionally) `Mode`. +2. **Describe each method** with the `golem.Desc("...")` option on `golem.DefineMethod`. +3. **Mount over HTTP** (optional) by setting `Spec.HTTP` and adding `golem.HTTP(...)` routes to methods. +4. **Build** — run `golem build`. + +## Spec fields (`agents/inventory/inventory.go`) + +```go +// Package inventory is the DEFINITION of the inventory agent. +package inventory + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID holds the constructor parameters and is the agent's type-level identity. +type ID struct{ WarehouseID string } + +type RestockIn struct { + SKU string + Quantity uint32 +} + +type PickIn struct { + SKU string + Quantity uint32 +} + +// Agent is the state-free definition. All declarative metadata lives on Spec. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "InventoryAgent", + Description: "Tracks per-warehouse stock levels", + Mode: golem.Durable, // default; state persists and replays deterministically +}) +``` + +`golem.Spec` (see `sdks/go/golem/golem.go:160`) has these fields: + +| Field | Type | Meaning | +|-------|------|---------| +| `Name` | `string` | Wire-level agent type name, as seen by the platform and other agents. **Required.** | +| `Description` | `string` | Free-text description surfaced in the agent-type metadata. | +| `Mode` | `golem.Mode` | `golem.Durable` (default) or `golem.Ephemeral`. | +| `HTTP` | `*golem.Mount` | When set, mounts the agent's methods under an HTTP path prefix (see below). | +| `Snapshot` | `golem.SnapshotPolicy` | Snapshot cadence; zero value disables snapshotting. | + +### Mode + +- **`golem.Durable`** — the default (`Mode` zero value). State persists across invocations and replays deterministically on recovery. +- **`golem.Ephemeral`** — no state is persisted across invocations. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "StatelessScorer", + Mode: golem.Ephemeral, +}) +``` + +## Describing methods + +Attach `golem.Desc("...")` to a method to set the description carried in the schema. Setting it more than once for the same method is a **definition error**, not a silent overwrite. + +```go +var ( + CheckStock = golem.DefineMethod[ID, string, uint32]("check-stock", + golem.Desc("Returns the number of units in stock for the given SKU; 0 if unknown.")) + + Restock = golem.DefineMethod[ID, RestockIn, uint32]("restock", + golem.Desc("Increases the stock count for the given SKU by the amount; returns the new total.")) + + // Model an observable failure in the result type, and describe it. + Pick = golem.DefineMethod[ID, PickIn, golem.Result[uint32, string]]("pick", + golem.Desc("Decreases stock for the given SKU; returns err if there is insufficient stock.")) +) +``` + +Method options compose — pass several in one `DefineMethod` call (e.g. `golem.Desc(...)` together with `golem.HTTP(...)` or `golem.ReadOnly()`). + +## Mounting over HTTP + +Set `Spec.HTTP` to a `*golem.Mount` and add `golem.HTTP(...)` routes per method. Every `ID` field must appear as a `{var}` in the mount path so the platform can identify the instance. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "InventoryAgent", + Description: "Tracks per-warehouse stock levels", + HTTP: &golem.Mount{ + Path: "/warehouses/{warehouseID}", // {warehouseID} binds ID.WarehouseID + CORS: []string{"*"}, + }, +}) + +var CheckStock = golem.DefineMethod[ID, string, uint32]("check-stock", + golem.Desc("Returns units in stock for the given SKU."), + golem.HTTP(golem.GET("/stock/{sku}"))) +``` + +`golem.Mount` fields (`sdks/go/golem/http_mount.go:46`): `Path` (required), `Auth`, `CORS`, `PhantomAgent`, `WebhookSuffix`. Verb constructors are `golem.GET/POST/PUT/DELETE/PATCH/...` and `golem.Custom("VERB", "/path")`. For full route-binding rules (path/query/header/body, per-route auth and CORS) load [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go). + +## Key Constraints + +- `Spec.Name` is **required** and is the wire-level type name — keep it stable, other agents address this agent by it. +- `Mode` defaults to `golem.Durable` (the zero value); set `golem.Ephemeral` only for stateless agents. +- `golem.Desc(...)` and `golem.HTTP(...)` are **definition-side** metadata on `DefineMethod`; they never change handler behavior. +- Setting `Desc` more than once on one method is a definition error reported at discovery. +- There is **no separate "prompt" annotation** in the Go SDK today. Unlike Rust's `#[prompt]`/`#[description]` pair, Go exposes only the single `Description`/`Desc` text (the schema's prompt-hint field is always emitted empty; see `sdks/go/golem/schema.go:196`). Put the LLM-facing guidance in the description. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Create the agent's definition + implementation from scratch | +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Full HTTP mount/route binding rules (path/query/header/body, auth, CORS) | +| [`golem-mark-read-only-go`](/next/how-to-guides/go/golem-mark-read-only-go) | Mark a method read-only and configure result caching | +| [`golem-configure-durability-go`](/next/how-to-guides/go/golem-configure-durability-go) | Tune durability/retry behavior for a durable agent | diff --git a/docs/src/content/next/how-to-guides/go/golem-atomic-block-go.mdx b/docs/src/content/next/how-to-guides/go/golem-atomic-block-go.mdx new file mode 100644 index 0000000000..b628d91d30 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-atomic-block-go.mdx @@ -0,0 +1,191 @@ +# Atomic Regions and Durability Controls (Go) + +## Overview + +Golem provides **automatic durable execution** — all agents are durable by +default. The helpers in this skill are **advanced controls** that most agents +never need. Reach for them only when you have a specific requirement around +atomicity, idempotency, or oplog replication. + +They live in the `golem` package (`golem.Atomically`, `golem.WithIdempotenceMode`, +`golem.OplogCommit`, `golem.GenerateIdempotencyKey`) +and are thin, **fail-loud** wrappers over host functions: on a host failure they +trap and surface as an agent-error — there is no in-band error return. + +> **Concurrency note.** These knobs apply at the **worker level**, not per +> goroutine. Golem runs an agent single-threaded with cooperative task-switching +> only at await points (RPC, promise, sleep). A scope is safe as long as you don't +> hold it open across a concurrent await (e.g. a `CallAsync` fan-out); nesting on a +> single logical flow is fine. + +## Atomic Regions + +Group **external, observable side effects** (RPC to other agents, and other +durable host calls) so that on a crash the whole group replays together. If the agent +fails partway through, recovery re-executes the **entire** region from the start — +so effects performed before the crash happen again (all-or-nothing). + +`golem.Atomically(f func())` runs `f` as one region: on normal return it commits; +if `f` **panics**, the region stays open and the runtime re-executes the whole +region on retry. Panicking is therefore the way to abort a region, consistent with +the fail-loud model. + +`f` takes no arguments and returns nothing — **return a value by capturing it in +an outer variable**: + +```go +// Reserve inventory and charge the customer — if we crash between them, we want +// recovery to re-run BOTH calls, not skip the reservation. +var orderID string +golem.Atomically(func() { + reservation := inventory.Reserve.Call(invClient, inventory.ReserveIn{Item: item, Qty: qty}) + charge := payment.Charge.Call(payClient, payment.ChargeIn{Customer: cust, Amount: price}) + orderID = combine(reservation, charge) +}) +``` + +> **What this is NOT.** `Atomically` is not an STM/transaction primitive and not +> for grouping in-memory state mutations. Agents are single-threaded and in-memory +> state is rebuilt by oplog replay on recovery, so wrapping plain in-memory updates +> does nothing useful: +> +> ```go +> // DON'T. The oplog already rebuilds these deterministically on replay. +> golem.Atomically(func() { +> ctx.State.balance -= amount +> ctx.State.lastTx = now +> }) +> ``` +> +> It is also **not** how you shrink the oplog or speed up recovery — for that use +> snapshots (see [`golem-configure-durability-go`](/next/how-to-guides/go/golem-configure-durability-go)). Use `Atomically` only when you +> have **two or more external side effects** that must not be left half-applied +> across a crash. For compensating multi-step workflows, prefer the saga helpers in +> [`golem-add-transactions-go`](/next/how-to-guides/go/golem-add-transactions-go), which build on this primitive. + +> **Outgoing HTTP inside a region.** Cross-agent RPC works inside `Atomically`, as +> above. An outgoing HTTP request (`net/http`) does not yet: the region fails to +> close with *"non-re-executable durable calls initiated in it are still in +> flight"*. Until that is resolved, make HTTP calls outside the region — or reach +> for them through RPC to an agent that owns the call. + +## Custom Durability for Libraries + +The low-level `golem:durability@1.6.0` interface is for **SDK and library authors**, +not an application tuning knob. It lets a library record several raw host effects +as one custom durable operation. `golem.DurableOp[In, Out]` owns the live +invocation: on the live path it runs the body, encodes and persists the typed +result, and returns it; on replay it returns the recorded result **without +running the body**. + +```go +result := golem.DurableOp( + golem.DurableSpec{ + Interface: "my-lib", + Function: "fetch", + Type: golem.WriteRemote, // commit/replay policy + }, + request, // recorded alongside the result, so the oplog is self-describing + func() FetchResult { // runs only on the live path + return doRawSideEffect(request) + }, +) +``` + +Failure has two distinct channels: + +- **Return a value** to record the outcome. If `Out` is a `golem.Result[Ok, Err]`, + an `Err` is a *recorded durable failure* — persisted and replayed like any other + value, so the operation is **not** retried. There is no separate fallible API: + the general schema codec already encodes `golem.Result` as a WIT `result`. +- **Panic** for a transient defect: the unfinished invocation is dropped without an + `End`, so recovery **re-executes** the whole body. Use `panic` / `golem.Must` + when the effect should be retried rather than recorded. + +`Type` (`golem.DurableFunctionType`) picks the commit/replay policy: `ReadLocal`, +`WriteLocal`, `ReadRemote`, `WriteRemote` (the usual choice for an external side +effect), or `WriteRemoteBatched(begin...)` / `WriteRemoteTransaction(begin...)` to +group writes. Set `DurableSpec.ForcedCommit` to force an efficient oplog commit at +the end. There is no async variant — a blocking body already suspends the fiber. + +Make repeated attempts safe: choose the correct `Type` classification, use external +idempotency keys, or wrap the work in a transaction ([`golem-add-transactions-go`](/next/how-to-guides/go/golem-add-transactions-go)). + +## Idempotence Mode + +`golem.WithIdempotenceMode(idempotent)` sets the mode and returns a `restore` +function; scope it with `defer`. The **default is `true`** — side effects are +treated as idempotent and Golem gives at-least-once semantics: + +```go +// Opt OUT of the default for a specific block — treat the effect as +// non-idempotent (at-most-once): the agent fails if it is unknown whether the +// side effect already ran, rather than risk running it twice. +func() { + defer golem.WithIdempotenceMode(false)() + // a non-idempotent side effect whose accidental duplication is worse than + // missing it entirely +}() +``` + +Use `false` only when accidental duplication of a side effect would be more +harmful than missing the call. + +## Durable Idempotency Key + +`golem.GenerateIdempotencyKey()` returns a `golem.UUID` that is **stable across +replay** — it is persisted and committed, so you can hand it to a third-party +system (e.g. a payment processor) to make an external call idempotent: + +```go +key := golem.GenerateIdempotencyKey() +// key.String() is stable across restarts — safe as a payment idempotency key +resp := payment.Charge.Call(client, payment.ChargeIn{Amount: amt, Key: key.String()}) +``` + +## Oplog Commit + +`golem.OplogCommit(replicas uint8)` 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: + +```go +golem.OplogCommit(3) // ensure the oplog is replicated to 3 replicas before proceeding +``` + +## Retry policy for a block + +There is no `WithRetryPolicy` in the `golem` package. To override retry behavior +for a scope, use the `retry` subpackage — `retry.With(...)` applies a named rule +for the current call and restores the previous one on return. See +[`golem-retry-policies-go`](/next/how-to-guides/go/golem-retry-policies-go). + +## Not available in the Go SDK + +The Rust SDK exposes separate `_async` variants (`atomically_async`, +`with_idempotence_mode_async`, `with_retry_policy_async`). The Go SDK has **no +async variants** — Go does not +split sync/async APIs. `golem.Atomically` takes a plain `func()`, and the +idempotence scope is `defer`-based; blocking operations (RPC, HTTP, promises) +already suspend the fiber at their await points, so a single API covers both +cases. + +## Key Constraints + +- `golem.Atomically` takes `func()` and returns nothing — capture results in an + outer variable; abort by panicking. +- `WithIdempotenceMode` returns a `restore func()` — call it (usually via + `defer`) or the scope never ends. +- These knobs are **worker-global**, not per-goroutine — don't hold a scope open + across a concurrent await. +- Failures trap and surface as agent-errors; there is no error return value. +- `GenerateIdempotencyKey` is the only helper that returns a value + (`golem.UUID`); the rest return nothing or a `restore` closure. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-transactions-go`](/next/how-to-guides/go/golem-add-transactions-go) | Multi-step workflows with compensation (saga), built on atomic regions | +| [`golem-retry-policies-go`](/next/how-to-guides/go/golem-retry-policies-go) | Override retry behavior for a scope (`retry.With`) | +| [`golem-configure-durability-go`](/next/how-to-guides/go/golem-configure-durability-go) | Reduce oplog/replay cost with snapshots; choose durable vs ephemeral | +| [`golem-make-http-request-go`](/next/how-to-guides/go/golem-make-http-request-go) | The outgoing calls you typically wrap in an atomic region | diff --git a/docs/src/content/next/how-to-guides/go/golem-call-another-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-call-another-agent-go.mdx new file mode 100644 index 0000000000..f03a8cc342 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-call-another-agent-go.mdx @@ -0,0 +1,105 @@ +# Calling Another Agent (RPC) in Go + +## Overview + +Agents talk to each other through the callee's **definition** package. You get a typed client from `Agent.Get(id)` and call a method descriptor on it. The caller imports only the callee's **definition** package (its `ID`, its method descriptors) — never its `impl` — so the two implementations never form a Go import cycle. + +Calls are durable: results are recorded in the oplog and replayed after a restart rather than re-issued. + +## Steps + +1. **Import the callee's definition package** (e.g. `myapp/agents/ledger`). +2. **Get a client** for a specific instance: `ledger.Agent.Get(ledger.ID{Region: "eu"})`. +3. **Call a method descriptor** on the client: `ledger.Record.Call(client, ledger.RecordIn{Amount: 10})`. +4. If the method returns a `golem.Result`, unwrap it (`.MustOk()` or inspect it). + +## Synchronous call + +```go +package impl + +import ( + "myapp/agents/ledger" + "myapp/agents/rpccaller" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(rpccaller.Agent, func(rpccaller.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, rpccaller.Call, func(_ *golem.Context[state], in rpccaller.CallIn) int64 { + // Get a client for the ledger instance identified by region. + c := ledger.Agent.Get(ledger.ID{Region: in.Region}) + // Call returns the method's Out; here Out is a golem.Result, unwrapped with MustOk. + return ledger.Record.Call(c, ledger.RecordIn{Amount: in.Amount}).MustOk() + }) +} +``` + +`Call` blocks until the callee returns. Because a single agent processes invocations sequentially, a **synchronous self-call** (calling back into the same instance) would deadlock — use `Trigger`/`Schedule` for self-messaging (see [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go)). + +### Plain vs Result returns + +`Call` returns the method's declared output type **directly**. Only unwrap when that type is a `golem.Result` — don't append `.MustOk()` to a plain return: + +```go +// greeter.Hello returns a plain string → use it directly +greeting := greeter.Hello.Call(c, greeter.HelloIn{Name: "alice"}) + +// ledger.Record returns golem.Result[int64, string] → unwrap +total := ledger.Record.Call(c, ledger.RecordIn{Amount: 10}).MustOk() +``` + +## Asynchronous call + +Start the call, do other work, then await: + +```go +fut := ledger.Record.CallAsync(c, ledger.RecordIn{Amount: in.Amount}) // *golem.Future[Out] +// ... other work ... +total := fut.Get().MustOk() // Get() blocks for the result +``` + +Launch several and await them to fan out work across other agents. + +## Unwrapping a `golem.Result` + +When a method's output is `golem.Result[Ok, Err]`: + +```go +res := ledger.Record.Call(c, in) // golem.Result[int64, string] +switch { +case res.IsErr(): + // handle the domain error value + msg := res.Err() + _ = msg +default: + total := res.Ok() + _ = total +} + +// Or fail loud (panic on Err, which the SDK turns into an agent-error): +total := ledger.Record.Call(c, in).MustOk() +``` + +## Import-cycle rule (important) + +- **impl packages never import each other.** All cross-agent references go through the callee's **definition** package, which imports only the SDK. +- This keeps the import graph a DAG no matter how cyclic the *call* graph is (A↔B mutual calls are fine as long as each impl imports the other's def, not its impl). + +## Key Constraints + +- You call `Method.Call(client, in)` (not `client.Call(method, in)`): the method descriptor carries the input/output types. Same for `Trigger`, `Schedule`, `CallAsync`. +- The client comes from the **definition** (`Def.Agent.Get(id)`); the ID is encoded from the `ID` type, so the caller does not need the callee locally registered. +- Don't hold a `*golem.Future` across invocations — await it (`Get()`) within the same handler. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-fire-and-forget-go`](/next/how-to-guides/go/golem-fire-and-forget-go) | Enqueue a call without awaiting a result (`Trigger`) | +| [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go) | An agent messages itself / schedules future work | +| [`golem-multi-instance-agent-go`](/next/how-to-guides/go/golem-multi-instance-agent-go) | Address a specific instance (or a phantom) by ID | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent being called | diff --git a/docs/src/content/next/how-to-guides/go/golem-call-from-external-go.mdx b/docs/src/content/next/how-to-guides/go/golem-call-from-external-go.mdx new file mode 100644 index 0000000000..49548b7ee8 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-call-from-external-go.mdx @@ -0,0 +1,126 @@ +# Calling Go Agents from Outside Golem + +## Overview + +Agents defined with the Go SDK are reached from outside the platform through **language-agnostic** entry points: + +1. **The `golem` CLI** — `golem agent invoke` calls a method and waits for the result. +2. **HTTP endpoints** — if the agent declares an HTTP mount, external clients (including a Go `net/http` client) call its methods over plain HTTP. +3. **The worker REST API** — invoke methods and complete promises directly over HTTP against the Golem server. + +> **No Go bridge SDK.** The `bridge:` generator produces typed external client crates/packages for TypeScript, Rust, MoonBit, and Scala — there is **no Go external bridge generator**. From an external **Go** program, call agents over the REST API or the agent's HTTP endpoints with the standard library (`net/http`), as shown below. + +Throughout, the example is a `CounterAgent` whose Go `ID` is `struct{ Name string }` with methods `increment`, `add`, and `value`. + +## Approach 1: the CLI + +`golem agent invoke` calls a method on a deployed agent and blocks for the result. The agent is created automatically on first invocation. Both `golem` and `golem-cli` work for every command. + +```shell +golem agent invoke [ARGUMENTS...] +``` + +### Agent ID format + +The agent ID is the agent type name plus its constructor parameters — the fields of the Go `ID` struct, in declaration order: + +``` +AgentTypeName(param1, param2, ...) +``` + +`CounterAgent`'s `ID` is `struct{ Name string }`, so its ID is `CounterAgent("my-counter")`. A singleton (`type ID struct{}`) uses empty parentheses: `CounterAgent()`. IDs may be prefixed with `env/`, `app/env/`, or `account/app/env/`. + +### Examples + +```shell +# No-parameter method +golem agent invoke 'CounterAgent("my-counter")' increment + +# add takes one parameter (the By field of AddIn), passed positionally +golem agent invoke 'CounterAgent("my-counter")' add 5 + +# Read the current value +golem agent invoke 'CounterAgent("my-counter")' value + +# In a specific environment +golem agent invoke 'staging/CounterAgent("my-counter")' value + +# With an explicit idempotency key +golem agent invoke -i my-unique-key 'CounterAgent("my-counter")' increment + +# Machine-readable output +golem agent invoke --format json 'CounterAgent("my-counter")' value +``` + +### CLI options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | Only trigger the invocation without waiting (fire-and-forget) | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | +| `--schedule-at ` | Schedule the invocation (requires `--trigger`; ISO 8601) | +| `--format json` / `--format yaml` | Machine-readable output | + +Method arguments use the CLI's WIT value syntax: strings quoted (`"my-counter"`), integers bare (`5`), booleans `true`/`false`, options `some(v)`/`none`, results `ok(v)`/`err(v)`, records `{ field-one: 1 }`. Each exported field of a Go input struct is one positional parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). + +## Approach 2: HTTP endpoints + +If the agent declares an HTTP mount, its methods are reachable over plain HTTP from any client. Declare the mount on the `Spec` and per-method routes with `golem.HTTP`: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + HTTP: &golem.Mount{Path: "/counters/{name}"}, // {name} binds the ID field +}) + +var Add = golem.DefineMethod[ID, AddIn, int64]("add", + golem.HTTP(golem.POST("/add?by={by}"))) +``` + +The agent must also be declared in the manifest's `httpApi` deployment. External clients then POST to the deployed route — from a Go program with the standard library: + +```go +resp, err := http.Post( + "https://my-golem.example.com/counters/my-counter/add?by=5", + "application/json", nil, +) +``` + +See [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) for the full mount/route model. + +## Approach 3: the worker REST API + +Call methods (or complete promises) directly against the Golem server over HTTP — usable from any language, including external Go: + +```shell +# Invoke and await a method +curl -X POST \ + "$GOLEM_URL/v1/components/$COMPONENT_ID/workers/$AGENT_ID/invoke-and-await?function=add" \ + -H 'Content-Type: application/json' \ + -d '{"params": [5]}' + +# Complete a promise an agent is awaiting (see golem-wait-for-external-input-go) +curl -X POST \ + "$GOLEM_URL/v1/components/$COMPONENT_ID/workers/$AGENT_ID/complete" \ + -H 'Content-Type: application/json' \ + -d '{"oplogIdx": , "data": []}' +``` + +`$AGENT_ID` is the same `AgentTypeName(params)` string the CLI uses. This is the mechanism a promise's `PromiseID` fields (`ComponentID`, `AgentID`, `OplogIndex`) feed into for external completion. + +## Key Constraints + +- `golem agent invoke` **blocks** until the agent returns; use `-t/--trigger` for fire-and-forget. +- Every invocation carries an idempotency key (auto-generated if not supplied), giving at-most-once execution even if the client retries. +- Constructor arguments in the agent ID must match the Go `ID` struct fields in order. +- There is **no generated Go external client** — from external Go, use the REST API / HTTP endpoints with `net/http`. Typed generated clients exist only for TypeScript, Rust, MoonBit, and Scala via `bridge:`. +- HTTP-endpoint access requires both a `Spec.HTTP` mount and an `httpApi` deployment declaration. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-invoke-agent-go`](/next/how-to-guides/go/golem-invoke-agent-go) | Full `golem agent invoke` reference and options | +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Expose the agent's methods over HTTP | +| [`golem-wait-for-external-input-go`](/next/how-to-guides/go/golem-wait-for-external-input-go) | Complete a promise from outside via REST | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent being called | diff --git a/docs/src/content/next/how-to-guides/go/golem-configure-durability-go.mdx b/docs/src/content/next/how-to-guides/go/golem-configure-durability-go.mdx new file mode 100644 index 0000000000..e10cf45b8e --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-configure-durability-go.mdx @@ -0,0 +1,191 @@ +# Configuring Agent Durability (Go) + +## Overview + +Durability is a property of the **agent definition** — it lives on the `golem.Spec` +you pass to `golem.DefineAgent`. There is no attribute or macro; you set two +struct fields: + +- `Mode` — `golem.Durable` (the default) or `golem.Ephemeral`. +- `Snapshot` — a `golem.SnapshotPolicy`, defaulting to `golem.SnapshotDisabled`. + +Nothing in the implementation package changes: handlers are written the same way +regardless of mode. + +## Steps + +1. **Decide the mode** — durable (default) unless the agent is genuinely stateless. +2. **Set `Mode`** on the `golem.Spec` in the definition package (omit it for durable). +3. **Add a snapshot policy** if the oplog would otherwise grow unboundedly. +4. **Build** — run `golem build`. + +## Durable Agents (Default) + +By default every Golem agent is **durable** — `Mode` defaults to `golem.Durable`, +so you never write it explicitly: + +- State persists across invocations, failures, and restarts. +- Every side effect is recorded in an **oplog** (operation log). +- On failure, the agent is transparently recovered by replaying the oplog. +- No special code needed — durability is automatic. + +You **cannot opt out of oplog writes for a durable agent** — the oplog is how +durability works. If oplog volume or replay cost is the concern (long-running +agents, heartbeats, polling, recurring tasks), do not try to skip persistence; +add **periodic snapshots** instead (below). + +```go +// Package counter is the DEFINITION of a standard durable agent. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +// Mode is omitted, so it defaults to golem.Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Description: "A simple durable counter", +}) + +var ( + Increment = golem.DefineMethod[ID, golem.Unit, int64]("increment", golem.Desc("Increase the count by one")) + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", golem.Desc("Return the current value")) +) +``` + +The implementation is ordinary — the private `state` is rebuilt by oplog replay +on recovery: + +```go +package impl + +import ( + "myapp/agents/counter" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ count int64 } + +var agent = golem.Implement(counter.Agent, func(counter.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.count++ + return ctx.State.count + }) + golem.Handle(agent, counter.Value, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.count + }) +} +``` + +## Durable with Periodic Snapshots + +Same durability guarantees as the default, but recovery starts from the **latest +snapshot** instead of replaying the whole oplog. Use this whenever the oplog grows +unboundedly — long-running agents, high-frequency state changes, heartbeats, +polling loops, recurring tasks. + +Set the `Snapshot` field on the `golem.Spec`: + +```go +import "time" + +// Snapshot every 10 invocations. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Snapshot: golem.SnapshotEveryN(10), +}) + +// Or at most once per interval. +var HeartbeatAgent = golem.DefineAgent[ID](golem.Spec{ + Name: "HeartbeatAgent", + Snapshot: golem.SnapshotPeriodic(30 * time.Second), +}) + +// Or let the platform pick the cadence. +var PipelineAgent = golem.DefineAgent[ID](golem.Spec{ + Name: "PipelineAgent", + Snapshot: golem.SnapshotDefault, +}) +``` + +The snapshot policy constructors are: + +| Constructor | Meaning | +|---|---| +| `golem.SnapshotDisabled` | The zero value — the platform never snapshots. | +| `golem.SnapshotDefault` | Snapshot at the platform's default cadence. | +| `golem.SnapshotEveryN(n uint16)` | Snapshot every `n` invocations. | +| `golem.SnapshotPeriodic(d time.Duration)` | Snapshot on a fixed time interval. | + +### What gets snapshotted + +Go reflection **cannot see unexported fields**, so the idiomatic private state +(e.g. an unexported `count`) is only captured if the state type implements the +`golem.Snapshotter` interface: + +```go +type Snapshotter interface { + Save() ([]byte, error) + Load([]byte) error +} +``` + +Without a `Snapshotter`, the snapshot is the JSON of the state's **exported** +fields only. If your durable state is unexported (the common case), implement +`Save`/`Load` on the `*state` before relying on snapshots. + +## Ephemeral Agents + +Use **ephemeral** mode for stateless, per-invocation agents where persistence is +not needed: + +- State is discarded after each invocation completes. +- No durable state across invocations — lower overhead. +- Useful for pure functions, request handlers, or adapters. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "StatelessHandler", + Mode: golem.Ephemeral, +}) +``` + +## When to Choose Which + +| Use Case | Mode | +|----------|------| +| Counter, shopping cart, workflow orchestrator | **Durable** (default) | +| Stateless request processor, transformer | **Ephemeral** | +| Long-running saga or multi-step pipeline | **Durable** (default) | +| Pure computation, no side effects worth persisting | **Ephemeral** | +| Agent that calls external APIs with at-least-once semantics | **Durable** (default) | +| Long-running agent with heartbeats, polling, or recurring tasks | **Durable + periodic snapshots** | +| Any durable agent whose oplog grows so large that replay is slow | **Durable + periodic snapshots** | + +When in doubt, use the default (durable). Ephemeral is an optimization for agents +that genuinely don't need persistence; add periodic snapshots whenever recovery +time matters. + +## Key Constraints + +- Mode and snapshot policy are set on the **definition** (`golem.Spec`), not the + implementation — the handler code is identical either way. +- `Mode` defaults to `golem.Durable`; only set it to switch to `golem.Ephemeral`. +- `Snapshot` defaults to `golem.SnapshotDisabled`; snapshots do not change + durability guarantees, only recovery time. +- **Read-only methods require a durable agent** — marking a method on an + `Ephemeral` agent read-only is a definition error (see [`golem-mark-read-only-go`](/next/how-to-guides/go/golem-mark-read-only-go)). +- Unexported private state is not captured by the default reflective snapshot; + implement `golem.Snapshotter` if you snapshot such an agent. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent and its methods in the first place | +| [`golem-mark-read-only-go`](/next/how-to-guides/go/golem-mark-read-only-go) | Add cacheable, side-effect-free query methods (durable only) | +| [`golem-atomic-block-go`](/next/how-to-guides/go/golem-atomic-block-go) | Fine-grained persistence / idempotency / atomicity controls | +| [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go) | Long-running agents that heartbeat or schedule future work | diff --git a/docs/src/content/next/how-to-guides/go/golem-create-agent-instance-go.mdx b/docs/src/content/next/how-to-guides/go/golem-create-agent-instance-go.mdx new file mode 100644 index 0000000000..424d92b6db --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-create-agent-instance-go.mdx @@ -0,0 +1,125 @@ +# Creating a Go Golem Agent Instance with `golem agent new` + +## Overview + +`golem agent new` **creates a new agent instance** without invoking any method on it. The agent is initialized with its constructor parameters and starts in an idle state, ready to receive invocations. + +Unlike `golem agent invoke` — which implicitly creates the agent on first call — `golem agent new` explicitly pre-creates it, which is useful when you need to set environment variables, configuration, or WASI config at creation time. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Choose any creation-time settings** — `--env`, `--config`, `--wasi-config` — if needed. +3. **Run `golem agent new`** to pre-create the instance. +4. **Invoke it later** with `golem agent invoke` using the same agent ID. + +## Usage + +```shell +golem agent new [OPTIONS] +``` + +## Agent ID Format + +The agent ID identifies the agent type and its constructor parameters: + +``` +AgentTypeName(param1, param2, ...) +``` + +For a Go agent, the constructor parameters are the fields of its `ID` struct in declaration order. `CounterAgent`'s `ID` is `struct{ Name string }`, so its ID is `CounterAgent("my-counter")`. For an agent whose `ID` has no fields (a singleton), use empty parentheses: `AgentTypeName()`. + +The agent ID can optionally be prefixed with environment or application paths: + +| Format | Description | +|--------|-------------| +| `AgentTypeName(params)` | Standalone agent name | +| `env/AgentTypeName(params)` | Environment-specific | +| `app/env/AgentTypeName(params)` | Application and environment-specific | +| `account/app/env/AgentTypeName(params)` | Account, application, and environment-specific | + +## Examples + +### Create an agent with constructor parameters + +```shell +golem agent new 'CounterAgent("my-counter")' +``` + +### Create a singleton agent (no constructor parameters) + +```shell +golem agent new 'CounterAgent()' +``` + +### Create an agent with environment variables + +```shell +golem agent new 'CounterAgent("my-counter")' --env API_KEY=sk-abc123 --env LOG_LEVEL=debug +``` + +### Create an agent with configuration + +```shell +golem agent new 'CounterAgent("my-counter")' --config max_retries=5 --config timeout_seconds=30 +``` + +### Create an agent with WASI config + +```shell +golem agent new 'CounterAgent("my-counter")' --wasi-config MY_WASI_VAR=some-value +``` + +### Create an agent in a specific environment + +```shell +golem agent new 'staging/CounterAgent("my-counter")' +``` + +### Combine environment variables and configuration + +```shell +golem agent new 'CounterAgent("my-counter")' \ + --env DATABASE_URL=postgres://... \ + --config batch_size=100 \ + --config retry_policy.max_attempts=3 +``` + +## Available Options + +| Option | Description | +|--------|-------------| +| `-e, --env ` | Environment variables visible to the agent (can be repeated) | +| `-c, --config ` | Configuration entries for the agent, using dot-separated paths (can be repeated). Only configuration declared by the agent can be provided. If not provided, the default from the manifest (`agents.*.config`) is used. | +| `-w, --wasi-config ` | WASI config entries visible to the agent (can be repeated). This is for compatibility with third-party libraries that depend on `wasi:config`; prefer typed configuration (`-c`) for your own agent config. | + +## When to Use `golem agent new` vs `golem agent invoke` + +- Use `golem agent new` when you need to **pre-create** an agent with specific environment variables, configuration, or WASI config before any invocation. +- Use `golem agent invoke` when you want to call a method — the agent is created automatically on first invocation if it doesn't exist. +- An agent created with `golem agent new` can be invoked later with `golem agent invoke` using the same agent ID. + +## Value Syntax + +Agent ID parameters use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Results: `ok(value)` / `err(value)`. +- Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- The constructor arguments must match the fields of the Go `ID` struct in order. +- If the component is not deployed yet and the CLI runs from an application directory, `golem agent new` auto-builds and deploys it before creating the agent. +- Only configuration declared by the agent can be provided via `-c`. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-invoke-agent-go`](/next/how-to-guides/go/golem-invoke-agent-go) | Invoke a method on the agent (creates it if absent) | +| [`golem-trigger-agent-go`](/next/how-to-guides/go/golem-trigger-agent-go) | Fire-and-forget invocation from the CLI | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent, its `ID`, and its methods | +| [`golem-multi-instance-agent-go`](/next/how-to-guides/go/golem-multi-instance-agent-go) | Address many instances of an agent by ID | diff --git a/docs/src/content/next/how-to-guides/go/golem-custom-snapshot-go.mdx b/docs/src/content/next/how-to-guides/go/golem-custom-snapshot-go.mdx new file mode 100644 index 0000000000..2dfe1f03b8 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-custom-snapshot-go.mdx @@ -0,0 +1,156 @@ +# Custom Snapshots in Go + +## Overview + +Snapshotting serializes a running Go agent's state so the host can save it and later restore it. It solves two problems: + +1. **Manual / snapshot-based component updates** — required when updating agents between incompatible component versions. +2. **Fast recovery and oplog compaction** — for long-running agents whose oplog grows over time (heartbeats, polling loops, recurring tasks, frequent state changes). Without snapshotting, every recovery replays the full oplog; with periodic snapshotting, recovery starts from the latest snapshot and replays only what came after it. + +> **You cannot opt out of oplog writes for a durable agent.** If you are worried about oplog volume or replay cost, do *not* try to skip persistence — enable snapshot-based recovery here instead. + +## Two things to set + +1. **A snapshot policy** on the agent's `Spec` — *whether and how often* the platform snapshots. Without a policy, no snapshots are taken. +2. **How the state serializes** — the default (JSON of **exported** fields) or a custom `golem.Snapshotter` implementation (needed for unexported state or a custom/binary format). + +## Step 1: enable a snapshot policy (`Spec.Snapshot`) + +Set `Snapshot` on the agent definition's `Spec`. The zero value is `golem.SnapshotDisabled`. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "SessionAgent", + Snapshot: golem.SnapshotEveryN(5), // snapshot every 5 invocations +}) +``` + +### Policy builders (from `golem.go`) + +| Builder | Meaning | +|---------|---------| +| `golem.SnapshotDisabled` | Zero value — never snapshot | +| `golem.SnapshotDefault` | Platform's default cadence (**note: the server default may itself be disabled** — prefer an explicit policy) | +| `golem.SnapshotPeriodic(d time.Duration)` | Snapshot at most once per interval | +| `golem.SnapshotEveryN(n uint16)` | Snapshot every `n` invocations (`SnapshotEveryN(1)` = every invocation) | + +```go +Snapshot: golem.SnapshotEveryN(1) // every invocation +Snapshot: golem.SnapshotPeriodic(30 * time.Second) // at most once per 30s +``` + +## Step 2a: automatic (default) snapshotting + +If you set a policy and do nothing else, the SDK JSON-encodes the state's **exported** fields. This is enough when all state you need to preserve lives in exported fields. + +> **Caveat:** Go reflection cannot see **unexported** fields. The idiomatic private state (e.g. an unexported `count`) is invisible to the default snapshot and would be **dropped**. To capture unexported state, implement `golem.Snapshotter` (Step 2b). + +## Step 2b: custom snapshotting (`golem.Snapshotter`) + +Implement `Save`/`Load` on the state type (pointer receiver) when you need to capture unexported fields, use a compact binary format, or migrate between schema versions: + +```go +type Snapshotter interface { + Save() ([]byte, error) + Load([]byte) error +} +``` + +When the state implements `Snapshotter`, its bytes are stored **verbatim** by the host (opaque payload) and handed back on restore — bypassing the reflective JSON path entirely. + +## Full example: session agent with custom snapshot + +### Definition (`agents/session/session.go`) + +```go +// Package session is the DEFINITION of the session agent. Its behaviour, private +// state, and custom snapshot serialization live in the impl subpackage. +package session + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ User string } + +type SpendIn struct{ Amount int64 } + +// Snapshot every 5 invocations instead of the default cadence. Mode defaults to Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "SessionAgent", + Description: "A session that snapshots its running total every few invocations", + Snapshot: golem.SnapshotEveryN(5), +}) + +var ( + Spend = golem.DefineMethod[ID, SpendIn, int64]("spend", golem.Desc("Add to the running total")) + Total = golem.DefineMethod[ID, golem.Unit, int64]("total", golem.Desc("Return the running total")) +) +``` + +### Implementation (`agents/session/impl/impl.go`) + +```go +// Package impl holds the session agent's private state, method handlers, and +// custom snapshot serialization. Importing it registers the agent. +package impl + +import ( + "encoding/binary" + + "myapp/agents/session" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state keeps a running total in an UNEXPORTED field. Reflection cannot see it, +// so the default snapshot (JSON of exported fields) would drop it — implementing +// golem.Snapshotter below is what makes the state survive. +type state struct{ total int64 } + +// Save/Load make *state a golem.Snapshotter: the returned bytes are stored +// verbatim by the host and handed back on restore, so unexported state is kept. +func (s *state) Save() ([]byte, error) { + b := make([]byte, 8) + binary.LittleEndian.PutUint64(b, uint64(s.total)) + return b, nil +} +func (s *state) Load(b []byte) error { + if len(b) == 8 { + s.total = int64(binary.LittleEndian.Uint64(b)) + } + return nil +} + +var agent = golem.Implement(session.Agent, func(session.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, session.Spend, func(ctx *golem.Context[state], in session.SpendIn) int64 { + ctx.State.total += in.Amount + return ctx.State.total + }) + golem.Handle(agent, session.Total, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.total + }) +} +``` + +## Best practices + +1. **Prefer the default JSON snapshot** unless you have unexported state, need a compact binary format, or need cross-version migration — in those cases implement `Snapshotter`. +2. **Version your format** — include a version byte or tag so `Load` can read snapshots written by an older `Save`. +3. **Keep snapshots small** — large snapshots slow recovery and updates. +4. **Test round-trips** — `Save` → `Load` should reproduce equivalent state (this is native, host-free, so it unit-tests easily). +5. **Handle migration** in `Load` when the schema changes between versions; returning an `error` from `Load` fails a snapshot-based update. + +## Key Constraints + +- A policy is required for snapshots to happen — `Spec.Snapshot` defaults to `SnapshotDisabled`, and `SnapshotDefault` may resolve to the server's default (possibly disabled). Use `SnapshotEveryN` / `SnapshotPeriodic` to guarantee it. +- `Snapshotter` is the **only** way to capture unexported state — the default reflective path sees exported fields only. +- Implement `Save` and `Load` as a pair on the state (usually pointer receiver); the host calls `Save` to capture and `Load` to restore. +- `Save`/`Load` return an `error`; a non-nil `Load` error fails the snapshot-based update. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent whose state is snapshotted | +| [`golem-configure-durability-go`](/next/how-to-guides/go/golem-configure-durability-go) | Other durability controls on an agent | +| [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go) | Long-running agents that benefit most from snapshotting | diff --git a/docs/src/content/next/how-to-guides/go/golem-enable-otlp-go.mdx b/docs/src/content/next/how-to-guides/go/golem-enable-otlp-go.mdx new file mode 100644 index 0000000000..c18217f5fa --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-enable-otlp-go.mdx @@ -0,0 +1,149 @@ +# Enabling OpenTelemetry for a Go Agent + +The `golem-otlp-exporter` is a built-in plugin that exports agent telemetry (traces, logs, metrics) to any OTLP-compatible collector via OTLP/HTTP. It runs on the platform side (as an oplog processor), so enabling it is a **manifest concern** — the configuration is the same regardless of the agent's language. No plugin installation is needed; just enable it in `golem.yaml`. + +## Step 1 — Enable the Plugin in golem.yaml + +Add the plugin to the component (or agent) that should emit telemetry: + +```yaml +components: + my-app:service: + plugins: + - name: golem-otlp-exporter + version: "1.5.0" + parameters: + endpoint: "http://localhost:4318" + signals: "traces,logs,metrics" +``` + +### Plugin Parameters + +| Parameter | Required | Description | +|-----------|----------|-------------| +| `endpoint` | Yes | OTLP collector base URL (e.g., `http://localhost:4318`) | +| `signals` | No | Comma-separated: `traces`, `logs`, `metrics`. Default: `traces` | +| `headers` | No | Comma-separated `key=value` HTTP headers (e.g., `x-api-key=secret`) | +| `service-name-mode` | No | `agent-id` (default) or `agent-type` | + +## Step 2 — Deploy + +```shell +golem deploy --yes +``` + +After deployment, newly created agents from this component automatically send telemetry to the configured collector. + +## What Gets Exported + +### Traces + +Spans are created automatically for: +- Agent invocations +- RPC calls to other agents +- Outgoing HTTP requests + +Trace and span IDs propagate from inbound HTTP requests (via code-first routes) and are included in outgoing HTTP request headers automatically. + +> **Custom spans:** the Rust SDK exposes a `golem::api::context` API (`start_span`, attributes, `current_context`) for creating your own spans in guest code. **The Go SDK does not currently expose a public wrapper for this** — the underlying `golem:api/context` bindings exist internally but are not part of the public Go API. Go agents get the automatic invocation/RPC/HTTP spans above; hand-authored custom spans are not available from Go yet. + +### Logs + +When `logs` is included in `signals`, all log output is forwarded to the OTLP collector. Use the standard library `log/slog` — the runtime routes it through the host logging channel and, in turn, to the collector. See the [`golem-logging-go`](/next/how-to-guides/go/golem-logging-go) skill for full logging guidance. + +```go +import "log/slog" + +slog.Info("hello from Go") +slog.Debug("this is a debug log entry", "step", 1) +``` + +### Metrics + +When `metrics` is included in `signals`, the following metrics are exported: + +| Metric | Type | Description | +|--------|------|-------------| +| `golem_invocation_count` | Counter | Number of agent method invocations | +| `golem_invocation_duration_ns` | Counter | Invocation duration | +| `golem_invocation_fuel_consumed` | Counter | Fuel consumed by invocations | +| `golem_invocation_pending_count` | Counter | Number of pending invocations | +| `golem_host_call_count` | Counter | Number of internal host calls | +| `golem_log_count` | Counter | Number of log entries emitted | +| `golem_memory_initial_bytes` | Gauge | Initially allocated memory | +| `golem_memory_total_bytes` | Gauge | Total allocated memory | +| `golem_memory_growth_bytes` | Counter | Memory growth since start | +| `golem_component_size_bytes` | Gauge | Component size in bytes | +| `golem_error_count` | Counter | Number of recorded errors | +| `golem_interruption_count` | Counter | Number of interrupt requests | +| `golem_exit_count` | Counter | Number of process exit signals | +| `golem_restart_count` | Counter | Number of times a fresh state was created | +| `golem_resources_created` | Counter | Number of internal resources created | +| `golem_resources_dropped` | Counter | Number of internal resources dropped | +| `golem_resources_active` | Gauge | Number of active internal resources | +| `golem_update_success_count` | Counter | Number of successful updates | +| `golem_update_failure_count` | Counter | Number of failed updates | +| `golem_transaction_committed` | Counter | Number of committed database transactions | +| `golem_transaction_rolled_back` | Counter | Number of rolled back database transactions | +| `golem_snapshot_size_bytes` | Counter | Snapshot size in bytes | +| `golem_oplog_processor_lag` | Gauge | Oplog processor delivery lag | + +Each metric includes `service.name`, `golem.agent.id`, `golem.component.id`, and `golem.component.version` attributes. + +## Local Observability Stack + +The Golem repository includes a ready-made Docker Compose setup at `docker-examples/otlp-collector/`: + +```shell +docker compose -f docker-examples/otlp-collector/docker-compose.yml up -d +``` + +This starts: +- **OTel Collector** on port 4318 (OTLP/HTTP) +- **Jaeger** on http://localhost:16686 (traces) +- **Prometheus** on http://localhost:9090 (metrics) +- **Loki** via Grafana (logs) +- **Grafana** on http://localhost:3000 (admin/admin) + +Configure the plugin with `endpoint: "http://localhost:4318"` to use this stack. + +## Per-Environment Configuration + +Use presets to vary the endpoint across environments: + +```yaml +components: + my-app:service: + plugins: + - name: golem-otlp-exporter + version: "1.5.0" + parameters: + endpoint: "http://localhost:4318" + signals: "traces,logs,metrics" + presets: + production: + pluginsMergeMode: replace + plugins: + - name: golem-otlp-exporter + version: "1.5.0" + parameters: + endpoint: "https://otel.prod.example.com:4318" + headers: "x-api-key={{ OTLP_API_KEY }}" + signals: "traces,logs,metrics" +``` + +Parameter values support Jinja-style `{{ VAR_NAME }}` substitution resolved against the host machine's environment variables at deploy time. + +## Key Points + +- **Built-in** — no `golem plugin register` needed, just add to `golem.yaml`. +- **Deploy required** — run `golem deploy` after adding the plugin configuration. +- Trace context propagates automatically through HTTP routes and RPC calls. +- **Custom spans are not available from the Go SDK yet** — Go agents get automatic spans (invocation, RPC, outgoing HTTP) only. +- Plugin can be activated/deactivated per agent with `golem agent activate-plugin` / `golem agent deactivate-plugin`. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-logging-go`](/next/how-to-guides/go/golem-logging-go) | Structured logging from Go agent code (forwarded when `logs` is enabled) | +| [`golem-manage-plugins`](/next/how-to-guides/common/golem-manage-plugins) | General plugin installation model (manifest sections, CLI, priority, per-environment config) | diff --git a/docs/src/content/next/how-to-guides/go/golem-file-io-go.mdx b/docs/src/content/next/how-to-guides/go/golem-file-io-go.mdx new file mode 100644 index 0000000000..a8540cba94 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-file-io-go.mdx @@ -0,0 +1,159 @@ +# File I/O in a Go Agent + +## Overview + +There is **no** Golem-specific filesystem API in the Go SDK — you use the Go standard library. Golem agents run on a WASI filesystem, and the standard `os` and `io` packages work against it out of the box (the same runtime that exposes `os.Getenv`/`os.Environ` also serves file operations). So read and write files with `os.ReadFile`, `os.WriteFile`, `os.Open`, `os.OpenFile`, etc., exactly as in ordinary Go. + +To provision files *into* an agent's filesystem at startup, declare them in the `files:` section of `golem.yaml` — load [`golem-add-initial-files`](/next/how-to-guides/common/golem-add-initial-files) for that. + +## Steps + +1. **Import** `os` (and `io`/`bufio` as needed) in your agent's `impl` package. +2. **Read** provisioned files with `os.ReadFile` / write with `os.WriteFile`. +3. **Provision** any initial files via the `files:` block in `golem.yaml` (see [`golem-add-initial-files`](/next/how-to-guides/common/golem-add-initial-files)). + +## Reading Files + +```go +import "os" + +// Text (or any) file → []byte +data, err := os.ReadFile("/data/config.json") +if err != nil { + // handle: with golem.Must this would abort+retry the invocation +} +text := string(data) +``` + +## Writing Files + +Only paths that are writable — files provisioned `read-write`, or paths not provisioned at all (e.g. `/tmp`) — can be written to. + +```go +import "os" + +err := os.WriteFile("/tmp/output.txt", []byte("Hello, world!"), 0o644) +``` + +### Appending + +```go +import "os" + +f, err := os.OpenFile("/tmp/agent.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644) +if err != nil { /* handle */ } +defer f.Close() +_, _ = f.WriteString("log line\n") +``` + +## Checking Existence and Listing + +```go +import ( + "errors" + "os" +) + +if _, err := os.Stat("/data/config.json"); errors.Is(err, os.ErrNotExist) { + // not present +} + +entries, err := os.ReadDir("/data") +for _, e := range entries { + _ = e.Name() +} +``` + +## Complete Agent Example + +Definition (`agents/reader/reader.go`): + +```go +// Package reader is the DEFINITION of a file-reading agent. +package reader + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type LogIn struct{ Message string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ReaderAgent", Description: "Reads a provisioned file and appends to a log", +}) + +var ( + Greeting = golem.DefineMethod[ID, golem.Unit, string]("greeting", golem.Desc("Read /data/greeting.txt")) + Log = golem.DefineMethod[ID, LogIn, golem.Unit]("log", golem.Desc("Append a line to /tmp/agent.log")) +) +``` + +Implementation (`agents/reader/impl/impl.go`): + +```go +// Package impl is the IMPLEMENTATION of the file-reading agent. +package impl + +import ( + "os" + "strings" + + "myapp/agents/reader" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(reader.Agent, func(reader.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, reader.Greeting, func(_ *golem.Context[state], _ golem.Unit) string { + // golem.Must aborts the invocation if the read fails. + data := golem.Must(os.ReadFile("/data/greeting.txt")) + return strings.TrimSpace(string(data)) + }) + + golem.Handle(agent, reader.Log, func(_ *golem.Context[state], in reader.LogIn) golem.Unit { + f := golem.Must(os.OpenFile("/tmp/agent.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)) + defer f.Close() + golem.Must(f.WriteString(in.Message + "\n")) + return golem.Unit{} + }) +} +``` + +`golem.Must` unwraps `(value, error)` and aborts the invocation (which then retries) on error — the fail-loud way to handle I/O errors when the caller should not observe them as a value. + +## Provisioning Initial Files (`golem.yaml`) + +Files are declared in the `files:` block and uploaded during deploy. Each entry has a `sourcePath`, an absolute `targetPath`, and optional `permissions`: + +```yaml +agents: + ReaderAgent: + files: + - sourcePath: ./data/greeting.txt + targetPath: /data/greeting.txt + permissions: read-only # default; cannot be written to + - sourcePath: ./data/scratch/ + targetPath: /var/scratch/ + permissions: read-write +``` + +See [`golem-add-initial-files`](/next/how-to-guides/common/golem-add-initial-files) for the full cascade (component / agent / preset levels), directory and remote sources, and merge modes. + +## Key Constraints + +- Use the **standard library** (`os`, `io`, `bufio`) — there is no SDK file API, and none is needed. The WASI filesystem backs it. +- Files provisioned with `read-only` (the default) **cannot be written**; write to `read-write` paths or unprovisioned paths like `/tmp`. +- `targetPath` values are **absolute** and unique across file entries. +- The filesystem is **per-agent-instance** and isolated; each instance has its own view. +- Initial files are declared at the **agent type** level in `golem.yaml`, not passed per instance at creation time. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-initial-files`](/next/how-to-guides/common/golem-add-initial-files) | Provision files into the agent filesystem via `golem.yaml` | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent that does the file I/O | +| [`golem-add-config-go`](/next/how-to-guides/go/golem-add-config-go) | Prefer typed config over files for structured settings | diff --git a/docs/src/content/next/how-to-guides/go/golem-fire-and-forget-go.mdx b/docs/src/content/next/how-to-guides/go/golem-fire-and-forget-go.mdx new file mode 100644 index 0000000000..a76547c930 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-fire-and-forget-go.mdx @@ -0,0 +1,61 @@ +# Fire-and-Forget Invocations in Go (`Trigger`) + +## Overview + +`Method.Trigger(client, in)` enqueues an invocation **without waiting for its result** and returns an `InvocationID`. Use it for notifications, fan-out, or handing work to a background/worker agent. Unlike a synchronous `Call`, `Trigger` does not block — so it is also safe for an agent to message **itself** (a synchronous self-`Call` would deadlock, since one instance handles one invocation at a time). + +## Steps + +1. **Import the target agent's definition package.** +2. **Get a client** with `Agent.Get(id)`. +3. **Trigger the method**: `Target.Method.Trigger(client, in)` — returns immediately. + +## Example + +```go +package impl + +import ( + "myapp/agents/coordinator" + "myapp/agents/worker" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(coordinator.Agent, func(coordinator.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, coordinator.Start, func(_ *golem.Context[state], in coordinator.StartIn) golem.Unit { + // Hand each unit of work to a worker without awaiting the outcome. + for _, w := range in.Jobs { + c := worker.Agent.Get(worker.ID{Name: w.Worker}) + worker.Dispatch.Trigger(c, worker.DispatchIn{Job: w.Job}) + } + return golem.Unit{} + }) +} +``` + +Fanning out is just a loop of `Trigger` calls — each runs independently on its target agent. + +## Trigger vs Call + +- `Call(c, in) Out` — blocks, returns the result. Use when you need the value. Never self-`Call`. +- `Trigger(c, in) InvocationID` — returns immediately, no result. Use for notifications, fan-out, and self-messaging. +- `CallAsync(c, in) *Future[Out]` — start now, await later with `Get()`. Use when you want the result but not to block yet (see [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go)). + +The returned `InvocationID` is an opaque handle to the enqueued invocation; you can ignore it for pure fire-and-forget. + +## Key Constraints + +- `Trigger` delivers a value-less enqueue: there is no way to read a return value from it. If you need the result, use `Call`/`CallAsync`. +- As with all RPC, `Trigger` is called on the **method descriptor** (`Worker.Dispatch.Trigger(client, in)`), and the client comes from the callee's **definition** (`worker.Agent.Get(id)`). + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | You need the callee's result (sync `Call` / async `CallAsync`) | +| [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go) | Schedule a future/self invocation at a specific time | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent being triggered | diff --git a/docs/src/content/next/how-to-guides/go/golem-http-params-go.mdx b/docs/src/content/next/how-to-guides/go/golem-http-params-go.mdx new file mode 100644 index 0000000000..40d94ede28 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-http-params-go.mdx @@ -0,0 +1,158 @@ +# HTTP Request and Response Parameter Mapping (Go) + +## Overview + +When a Go agent is exposed over HTTP (see [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go)), the platform maps parts of each request onto the agent's constructor (`ID`) fields and the method's **input struct** fields. This skill covers how path segments, query parameters, headers, and the request body bind to those fields, which Go types each binding accepts, and how return types map to HTTP responses. + +Binding is **metadata only** and declared on the definition: the mount `Path` on `Spec.HTTP` and the `golem.HTTP(...)` option on each method. There is no incoming-request handler in the guest. + +## Steps + +1. **Name fields to match wire names.** A path/query/header variable refers to an input field by its **lower-first** name: Go field `Sku` is `sku` on the wire, `MaxResults` is `maxResults`. +2. **Bind path variables** by putting `{name}` in the mount path (binds `ID` fields) or an endpoint path suffix (binds method input fields). +3. **Bind query and header values** inline (`?name={field}`) or with `golem.Query` / `golem.Header`. +4. **Leave body fields unbound** on body-carrying verbs; they arrive as JSON. + +## Path variables + +`{var}` segments bind by (lower-first) field name. + +- **Mount path** `{var}`s bind the agent's constructor (`ID`) fields. **Every `ID` field must appear as a `{var}`** so a request selects one instance. +- **Endpoint path** `{var}`s bind the method's input fields. + +```go +type ID struct{ Name string } // bound by {name} in the mount + +type LookupIn struct { + Sku string + Detailed bool +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CatalogAgent", + HTTP: &golem.Mount{Path: "/catalog/{name}"}, // {name} → ID.Name +}) + +// GET /catalog/{name}/items/{sku} — {sku} → LookupIn.Sku +var Lookup = golem.DefineMethod[ID, LookupIn, ItemInfo]("lookup", + golem.HTTP(golem.GET("/items/{sku}", golem.Query("detailed", "detailed")))) +``` + +The trailing catch-all `{*rest}` captures everything after a prefix and may only appear as the **last** endpoint segment; it is **not** allowed in a mount path. + +## Query parameters + +Two equivalent forms. Inline `?name={field}` in the path suffix, or `golem.Query(wire, field)` when the wire name differs from the field: + +```go +type SearchIn struct { + Query string + MaxResults uint64 +} + +// GET /catalog/{name}/search?q=hello&limit=10 +var Search = golem.DefineMethod[ID, SearchIn, []Result]("search", + golem.HTTP(golem.GET("/search", + golem.Query("q", "query"), // ?q= → SearchIn.Query + golem.Query("limit", "maxResults"), // ?limit= → SearchIn.MaxResults + ))) +``` + +Inline `golem.GET("/search?q={query}&limit={maxResults}")` is equivalent when the parameter name matches the field's wire name. + +## Header variables + +`golem.Header(wire, field)` maps a request header to an input field: + +```go +type DataIn struct { + RequestID string + Token string +} + +var GetData = golem.DefineMethod[ID, DataIn, Data]("getData", + golem.HTTP(golem.GET("/data", + golem.Header("X-Request-Id", "requestId"), + golem.Header("Authorization", "token"), + ))) +``` + +Header names are matched case-insensitively; binding the same header twice on one endpoint is a definition error. + +## Supported types for path, query, and header bindings + +A value bound from a URL path/query/header string must decode into a **scalar** Go field. Only these kinds bind: + +| Go type | Bound from | +|---|---| +| `string` | used as-is | +| `bool` | `"true"` / `"false"` | +| `int8`, `int16`, `int32`, `int64` | signed integer | +| `uint8`, `uint16`, `uint32`, `uint64` | unsigned integer | +| `float32`, `float64` | floating-point number | + +Binding a non-scalar field (struct, slice, map) from path/query/header is a definition error: *"cannot bind input field … only scalar fields decode from a URL"*. Such fields must arrive in the body instead. + +> Prefer sized integers throughout. Bare `int`/`uint` are rejected at the agent-schema level because their width is platform-dependent (see [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go)). + +## Request body mapping + +For body-carrying verbs (`POST`, `PUT`, `DELETE`, `PATCH`, …), any input field **not** bound to a path/query/header binding is populated from the JSON request body: + +```go +type UpdateIn struct { + Sku string // from the path + Name string // from the body + Count uint64 // from the body +} + +// POST /catalog/{name}/items/{sku} Body: {"name":"Widget","count":5} +var Update = golem.DefineMethod[ID, UpdateIn, Item]("update", + golem.HTTP(golem.POST("/items/{sku}"))) +``` + +Each unbound field becomes a top-level key in the JSON body object (field names lower-first / camelCase, as elsewhere in the SDK). + +`GET` and `HEAD` are **bodyless**: they carry no request body, so they must bind **every** input field from path/query/header. An unbound field on a bodyless verb is a definition error. + +## Return type to HTTP response mapping + +Handlers return their output value; the platform maps it to a response. In Go: + +| Return type | HTTP status | Body | +|---|---|---| +| `golem.Unit` | 204 No Content | empty | +| `T` (any type) | 200 OK | JSON-serialized `T` | +| `*T` | 200 OK if non-nil, 404 Not Found if nil | JSON `T` or empty | +| `golem.Result[T, E]` | 200 OK on `Ok`, 500 Internal Server Error on `Err` | JSON `T` or JSON `E` | + +`golem.Unit` is the empty result placeholder; `*T` is Golem's `option` (a nil pointer means "absent"); `golem.Result[Ok, Err]` returns the error as an observable value (see [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) on returning failures). + +## Data type to JSON mapping + +| Go type | JSON | +|---|---| +| `string` | string | +| sized ints / uints | number (integer) | +| `float32`, `float64` | number | +| `bool` | boolean | +| `[]T` | array | +| struct | object (lower-first / camelCase field names) | +| `*T` | value or `null` | +| `map[K]V` | object / WIT map | + +## Key Constraints + +- A variable can bind an input field from **exactly one** of path/query/header — binding it more than once is a definition error. +- Bindable path/query/header fields must be scalar; non-scalars go in the body. +- Bodyless verbs (`GET`, `HEAD`) must bind every input field. +- Field references on the wire use the **lower-first** field name (`Sku` → `sku`). +- **Go gap:** the Rust SDK's `UnstructuredBinary` / `UnstructuredText` (with `AllowedMimeTypes` / `AllowedLanguages`) raw-body wrapper types have **no public Go equivalent** yet — model bodies as JSON structs, or use `[]byte` fields for raw bytes. + +### Related Guides +| Guide | Description | +|---|---| +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | The high-level workflow of mounting an agent and adding routes | +| [`golem-add-http-auth-go`](/next/how-to-guides/go/golem-add-http-auth-go) | Require authentication on endpoints | +| [`golem-add-cors-go`](/next/how-to-guides/go/golem-add-cors-go) | Allow cross-origin requests | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent and its input/output types | diff --git a/docs/src/content/next/how-to-guides/go/golem-interactive-repl-go.mdx b/docs/src/content/next/how-to-guides/go/golem-interactive-repl-go.mdx new file mode 100644 index 0000000000..e702bf0664 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-interactive-repl-go.mdx @@ -0,0 +1,79 @@ +# Golem Interactive REPL (Go) + +The `golem repl` command starts an interactive REPL for testing and scripting agents. It supports both an **interactive mode** and a **script execution mode**. + +**There is no Go REPL language** in Golem. Use the **TypeScript REPL** (the default) to interact with your Go agents — all agent types are available as TypeScript classes regardless of the agent's source language. + +## Interactive Mode + +```shell +golem repl +``` + +Starts a TypeScript REPL with all agent client classes preconfigured in the global scope — including your Go agents. You can get or create agent instances, invoke methods, and see logs streamed during invocations, all with full type safety. + +### Example: Invoking a Go counter agent from the TypeScript REPL + +A Go `CounterAgent` whose `ID` is `struct{ Name string }` is addressed by that name, and its `increment` / `add` / `value` methods are exposed as camelCase client methods: + +```typescript +const c1 = await CounterAgent.get("c1") +await c1.increment() +await c1.add(5) +const value = await c1.value() +``` + +### Built-in Commands + +The REPL provides built-in commands that mirror CLI functionality. Commands accept both `.` and `:` prefixes: + +- `.build` / `:build` — build the project +- `.deploy` / `:deploy` — deploy components +- `.help` / `:help` — show available commands + +This lets you build, deploy, and test agents without leaving the REPL. + +## Script Mode + +Run a TypeScript file non-interactively: + +```shell +golem repl --script-file test.ts --yes +``` + +The `--yes` flag auto-confirms any prompts. The script has the same global scope as the interactive REPL — all agent client classes are available, including Go agents. + +Run the script after creating it, unless the user explicitly asked not to. + +### Example script (`test.ts`) + +```typescript +const c2 = await CounterAgent.get("c2") +await c2.increment() +await c2.increment() +``` + +Run it: + +```shell +golem repl --script-file test.ts --yes +``` + +## Available REPL Languages + +| Language | Flag | Interactive | Script | Notes | +|----------|------|-------------|--------|-------| +| TypeScript | (default) | ✅ | ✅ | Recommended — works with all agent languages | + +No Go REPL is available. The TypeScript REPL is recommended for interacting with Go agents. + +## Prerequisites + +- The Golem server must be running (`golem server run`) +- Components must be deployed (`golem deploy`) + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-invoke-agent-go`](/next/how-to-guides/go/golem-invoke-agent-go) | Invoke an agent method from the CLI (non-REPL) | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent you're testing | diff --git a/docs/src/content/next/how-to-guides/go/golem-invoke-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-invoke-agent-go.mdx new file mode 100644 index 0000000000..65fa7bd530 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-invoke-agent-go.mdx @@ -0,0 +1,112 @@ +# Invoking a Go Golem Agent with `golem agent invoke` + +## Overview + +`golem agent invoke` calls a method on a deployed agent and **waits for the result**. The agent is created automatically on first invocation if it does not exist yet. Standard output, error, and log streams from the agent are streamed live to the terminal by default. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Pick the method** to call (the WIT name, e.g. `increment`, `add`, `value`). +3. **Run `golem agent invoke`** with the agent ID, method name, and any arguments. +4. **Read the result** — text by default, or `--format json` / `--format yaml` for machine output. + +## Usage + +```shell +golem agent invoke [ARGUMENTS...] +``` + +## Agent ID Format + +The agent ID identifies the agent type and its constructor parameters: + +``` +AgentTypeName(param1, param2, ...) +``` + +For a Go agent, the constructor parameters are the fields of its `ID` struct in declaration order. `CounterAgent`'s `ID` is `struct{ Name string }`, so its ID is `CounterAgent("my-counter")`. For an agent whose `ID` has no fields (a singleton), use empty parentheses: `AgentTypeName()`. + +The agent ID can optionally be prefixed with environment or application paths: + +| Format | Description | +|--------|-------------| +| `AgentTypeName(params)` | Standalone agent name | +| `env/AgentTypeName(params)` | Environment-specific | +| `app/env/AgentTypeName(params)` | Application and environment-specific | +| `account/app/env/AgentTypeName(params)` | Account, application, and environment-specific | + +## Examples + +### Invoke a method with no parameters + +```shell +golem agent invoke 'CounterAgent("my-counter")' increment +``` + +### Invoke a method with an argument + +`add` takes one parameter (the `By` field of `AddIn`), passed positionally: + +```shell +golem agent invoke 'CounterAgent("my-counter")' add 5 +``` + +### Read the current value + +```shell +golem agent invoke 'CounterAgent("my-counter")' value +``` + +### Invoke in a specific environment + +```shell +golem agent invoke 'staging/CounterAgent("my-counter")' value +``` + +### Invoke with an explicit idempotency key + +```shell +golem agent invoke -i my-unique-key 'CounterAgent("my-counter")' increment +``` + +## Output + +Text output renders return values in a WIT value syntax. Methods returning `golem.Unit` or no value print `void` in text mode. + +For machine-readable output, use `--format json` or `--format yaml`. A single return value includes `result` plus `resultJson`; multiple return values include `result` plus `resultsJson`; methods returning no value omit result fields. + +## Available Options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | Only trigger the invocation without waiting for the result (fire-and-forget) | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | +| `--schedule-at ` | Schedule the invocation at a specific time (requires `--trigger`; ISO 8601 format) | + +## Value Syntax + +Agent ID parameters and method arguments use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Results: `ok(value)` / `err(value)`. +- Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- `golem agent invoke` **blocks** until the agent returns; use `--trigger` for fire-and-forget. +- Every invocation uses an idempotency key (auto-generated if not supplied), guaranteeing at-most-once execution even if the CLI retries. +- If the component is not deployed yet and the CLI runs from an application directory, the command auto-builds and deploys it before invoking. +- The agent ID's constructor arguments must match the fields of the Go `ID` struct in order. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-trigger-agent-go`](/next/how-to-guides/go/golem-trigger-agent-go) | Fire-and-forget invocation from the CLI (`--trigger`) | +| [`golem-schedule-agent-go`](/next/how-to-guides/go/golem-schedule-agent-go) | Schedule a future invocation from the CLI | +| [`golem-create-agent-instance-go`](/next/how-to-guides/go/golem-create-agent-instance-go) | Pre-create an agent instance (`golem agent new`) | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent and its methods | diff --git a/docs/src/content/next/how-to-guides/go/golem-logging-go.mdx b/docs/src/content/next/how-to-guides/go/golem-logging-go.mdx new file mode 100644 index 0000000000..e60de3a75b --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-logging-go.mdx @@ -0,0 +1,120 @@ +# Logging from a Go Agent + +## Overview + +Golem routes Go logging through the host's structured logging channel (`wasi:logging`), so each record carries a typed **level** and a **context** (category) string and shows up in worker logs and the oplog with the right severity. Unlike writing to stdout/stderr — which the host records as raw bytes with no level — this gives you filterable, leveled logs. + +The runtime installs the SDK's handler as the **default `log/slog` handler on agent startup**, so ordinary standard-library structured logging just works with **no setup code**. You only reach for the SDK's `log` package (`github.com/golemcloud/golem/sdks/go/golem/log`) when you want to customize the level or category, or build a handler yourself. + +## Steps + +1. **Log with the standard library** — call `slog.Info`, `slog.Warn`, etc. Nothing to import beyond `log/slog`. +2. **(Optional) Customize** the minimum level or base category with `log.SetDefault(...)` from the SDK's `log` package. +3. **View logs** with `golem agent stream` or during `golem agent invoke`. + +## Quick Start (no setup) + +The runtime already installed the host-logging handler as slog's default, so just use `log/slog`: + +```go +import "log/slog" + +slog.Info("order created", "orderID", orderID, "total", total) // -> level=info +slog.Warn("retrying", "attempt", attempt, "reqID", reqID) // -> level=warn +slog.Error("db connect failed", "err", err) // -> level=error +slog.Debug("processing item", "id", item.ID) // -> level=debug +``` + +Structured context is passed as trailing key/value pairs (slog attributes) and is rendered into the log record. `slog.With(...)` returns a logger that prepends attributes to every record: + +```go +logger := slog.With("area", "billing") +logger.Error("declined", "code", code) +``` + +Because `slog.SetDefault` also bridges Go's standard `log` package, plain `log.Print` / `log.Printf` output flows through the same channel too (as `info`-level records). + +## Log Levels + +Records map onto the `wasi:logging` severities. slog's built-in levels cover debug/info/warn/error; the SDK also defines trace and critical (`sdks/go/golem/log/log.go:47`): + +| slog call | Level | Use for | +|-----------|-------|---------| +| `slog.Log(ctx, level-4, ...)` (below Debug) | `trace` | Fine-grained control flow | +| `slog.Debug` | `debug` | Debugging information | +| `slog.Info` | `info` | Normal operations, monitoring | +| `slog.Warn` | `warn` | Degraded behavior, hazards | +| `slog.Error` | `error` | Serious errors | +| `slog.Log` a full step above Error | `critical` | Fatal conditions | + +The SDK exposes the raw severities as `log.Trace`, `log.Debug`, `log.Info`, `log.Warn`, `log.Error`, `log.Critical` (type `log.Level`) for the low-level `log.Log` helper. + +## Customizing the default logger + +Import the SDK's `log` package (alias it to avoid clashing with the standard `log`) and call `log.SetDefault` to change the minimum level or the base category. `Options` has just `Level` (an `slog.Leveler`) and `Context` (the base category string) — see `sdks/go/golem/log/log.go:103`. + +```go +import ( + "log/slog" + + golemlog "github.com/golemcloud/golem/sdks/go/golem/log" +) + +func init() { + // Emit debug-and-up, tagging every record with the "billing" category. + golemlog.SetDefault(&golemlog.Options{ + Level: slog.LevelDebug, + Context: "billing", + }) +} +``` + +## Building a handler yourself + +`log.NewHandler(opts)` returns an `*slog.Handler` you can pass to `slog.New` (for a scoped logger, or to compose): + +```go +handler := golemlog.NewHandler(&golemlog.Options{Context: "worker"}) +logger := slog.New(handler) +logger.Info("started") +``` + +slog groups map onto the category: `logger.WithGroup("retry")` extends the context to read like `worker/retry` rather than key-prefixing attributes. + +## Lower-level helpers + +- `log.Log(level, context, message)` — emit one raw record directly (`sdks/go/golem/log/log.go:58`). +- `log.Writer(level, context)` — an `io.Writer` where each write becomes one record at that level/category, handy for wiring a sink that expects an `io.Writer`. + +```go +golemlog.Log(golemlog.Warn, "startup", "cache warm skipped") +``` + +## Viewing Logs + +Stream live agent output (stdout, stderr, and the log channel): + +```shell +golem agent stream '' +``` + +Logs also stream automatically during an invocation: + +```shell +golem agent invoke '' '' [args] +# use --no-stream to suppress +``` + +## Key Constraints + +- **No initialization needed** — the runtime installs the host-logging handler as slog's default on startup; just use `log/slog`. +- Prefer `slog.*` over `fmt.Println`/stdout: stdout/stderr are captured as raw bytes with no level or category. +- Logging is a **side effect**: during replay (crash recovery) log calls from replayed operations are skipped — only new invocations produce log output. +- The SDK's package is named `log`, which collides with the standard library `log`; import it under an alias (e.g. `golemlog`). +- `int`/`uint`-width and other value formatting follow slog's attribute rendering (values are resolved and stringified into the message). + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-enable-otlp-go`](/next/how-to-guides/go/golem-enable-otlp-go) | Forward logs (and traces/metrics) to an OTLP collector | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent whose handlers emit these logs | diff --git a/docs/src/content/next/how-to-guides/go/golem-make-http-request-go.mdx b/docs/src/content/next/how-to-guides/go/golem-make-http-request-go.mdx new file mode 100644 index 0000000000..9041a70aae --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-make-http-request-go.mdx @@ -0,0 +1,71 @@ +# Outgoing HTTP Requests from a Go Agent + +## Overview + +Use the **standard library `net/http`** package directly. The SDK routes `net/http` through Golem's durable `wasi:http` transport, so each request is recorded in the oplog and **served from it on replay** after a restart rather than re-issued — outbound calls are effectively exactly-once across crashes/restarts. No manual wiring or custom transport is needed. + +## Steps + +1. **Import `net/http`** (and `io` to read the body). +2. **Make the request** — `http.Get(url)`, or build an `*http.Request` and use `http.DefaultClient.Do`. +3. **Read the response body**, then `Close` it. +4. Let failures propagate (panic) — Golem retries transparently; do **not** add manual retry loops. + +## Example + +```go +package impl + +import ( + "io" + "net/http" + "os" + + "myapp/agents/fetcher" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(fetcher.Agent, func(fetcher.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, fetcher.Fetch, func(_ *golem.Context[state], in fetcher.FetchIn) string { + url := "https://api.example.com/thing?q=" + in.Query + // golem.Must panics on error (the SDK turns the panic into an agent-error + // and retries per policy). Use it for calls that shouldn't fail normally. + resp := golem.Must(http.Get(url)) + defer resp.Body.Close() + return string(golem.Must(io.ReadAll(resp.Body))) + }) +} +``` + +`golem.Must(v, err)` returns `v` or panics on `err` — the fail-loud idiom for operations Golem should retry. To surface an HTTP failure to the caller as a *value* instead, return a `golem.Result` and inspect the error yourself (see [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) → Returning Failures). + +## POST / custom requests + +```go +req := golem.Must(http.NewRequest("POST", url, strings.NewReader(body))) +req.Header.Set("Content-Type", "application/json") +resp := golem.Must(http.DefaultClient.Do(req)) +defer resp.Body.Close() +``` + +## Durability & retries + +- The HTTP call is a durable operation: on replay the recorded response is returned, so the external service is **not** hit again. +- **Do not** write manual retry/backoff loops — Golem retries failed operations automatically (a default policy applies; customize with the retry-policy helpers only when the *strategy* must change). + +## Key Constraints + +- Target is **WASM**: there are no raw sockets. `net.Dial`, most database drivers, and custom transports won't work — outgoing traffic goes through the SDK's WASI-backed `net/http` transport. +- **Async handles cannot outlive an invocation**: read/consume the response within the same handler; don't stash an unresolved response/body in agent state to use later. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Expose *this* agent over HTTP (incoming requests) | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Call another Golem agent instead of an external HTTP service | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent making the request | diff --git a/docs/src/content/next/how-to-guides/go/golem-mark-read-only-go.mdx b/docs/src/content/next/how-to-guides/go/golem-mark-read-only-go.mdx new file mode 100644 index 0000000000..b0dcf62699 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-mark-read-only-go.mdx @@ -0,0 +1,152 @@ +# Marking Agent Methods as Read-Only (Go) + +## Overview + +A **read-only** method is one you promise is a pure read of the agent's +already-loaded state. Golem enforces the most important part of the contract: the +runtime **traps outgoing HTTP and agent RPC** from a read-only method. In +exchange, Golem **caches the result** per the chosen cache policy. + +You mark a method read-only by passing the `golem.ReadOnly(...)` option to +`golem.DefineMethod` in the **definition** package — it is a `golem.MethodOpt`, +just like `golem.Desc(...)` and `golem.HTTP(...)`. + +## Steps + +1. **Add `golem.ReadOnly()`** as an option on the method descriptor in the def package. +2. **(Optional) choose a cache policy** — pass `golem.NoCache()`, `golem.CacheUntilWrite()`, or `golem.CacheFor(ttl)`. +3. **Keep the handler pure** — no outgoing HTTP, no RPC, no mutation of durable state. +4. **Build** — run `golem build`. + +## Usage + +```go +// Package counter is the DEFINITION. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{Name: "CounterAgent"}) + +var ( + // Read-write: mutates shared state. + Increment = golem.DefineMethod[ID, golem.Unit, int64]("increment") + + // Read-only: pure read over already-loaded state (default cache policy). + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", golem.ReadOnly()) +) +``` + +The implementation is unchanged — a read-only method is an ordinary handler that +happens not to perform side effects: + +```go +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.count++ + return ctx.State.count + }) + golem.Handle(agent, counter.Value, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.count // pure read + }) +} +``` + +## Cache Policy + +Pass at most one `golem.CachePolicy` to `golem.ReadOnly(...)`. The default (no +argument) is `CacheUntilWrite`. + +| Policy | Call | Behavior | +|---|---|---| +| Until write (default) | `golem.ReadOnly()` or `golem.ReadOnly(golem.CacheUntilWrite())` | Cached until any mutating (non-read-only) method of the agent completes | +| TTL | `golem.ReadOnly(golem.CacheFor(30 * time.Second))` | Expires after the given duration even without a write | +| No cache | `golem.ReadOnly(golem.NoCache())` | Runs every time; still side-effect-free, never cached | + +```go +import "time" + +var ( + // Cached until the next write. + Catalog = golem.DefineMethod[ID, golem.Unit, Catalog]("catalog", golem.ReadOnly()) + + // Cached for a minute regardless of writes. + Rates = golem.DefineMethod[ID, golem.Unit, Rates]("rates", golem.ReadOnly(golem.CacheFor(time.Minute))) + + // Never cached, but still trapped against remote side effects. + Compute = golem.DefineMethod[ID, ComputeIn, int64]("compute", golem.ReadOnly(golem.NoCache())) +) +``` + +`golem.CacheFor` requires a **positive** ttl — `golem.CacheFor(0)` (or a negative +duration) is a definition error; use `golem.NoCache()` to disable caching. + +## What the Runtime Enforces (and what it doesn't) + +A read-only method must be a pure function of the agent's already-loaded state and +its inputs. + +| Allowed | Trapped by the runtime | Not checked — your responsibility | +|---|---|---| +| Reading `ctx.State` fields | Outgoing HTTP requests | Mutating `ctx.State` in memory | +| Computation over inputs | RPC calls to other agents | Reading the clock / current time | +| Returning derived values | | Randomness | +| | | Reading environment variables | + +- **Outgoing HTTP and agent RPC trap** with a read-only violation before they run. + A read-only method therefore cannot call another agent — do read-only RPC + fan-out from a regular method instead (see [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go)). +- **In-memory mutation, clocks, randomness, and env reads are NOT detected.** They + do not trap, but they break the cache contract (a cached, stale, or + non-deterministic value). Keeping the method pure is up to you. If you need any + of them, use a regular (non-read-only) method. + +## Common Pitfalls + +- **Read-only on an `Ephemeral` agent is a definition error** — ephemeral agents + have no shared state to read. Remove `golem.ReadOnly()` or make the agent + durable (see [`golem-configure-durability-go`](/next/how-to-guides/go/golem-configure-durability-go)). +- **Setting `golem.ReadOnly()` twice on one method is a definition error**, as is + passing **more than one** cache policy — both are reported at discovery. +- **`golem.NoCache()` does not relax the contract** — it only disables caching; + outgoing HTTP and RPC still trap and the same purity rules apply. + +## HTTP endpoints + +Read-only methods are the natural fit for HTTP `GET`/`HEAD` endpoints. Combine +`golem.ReadOnly(...)` with `golem.HTTP(golem.GET(...))` on the same method (see +[`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go)): + +```go +var Catalog = golem.DefineMethod[ID, golem.Unit, Catalog]("catalog", + golem.ReadOnly(), + golem.HTTP(golem.GET("/catalog"))) +``` + +## Not available in the Go SDK + +Unlike the Rust SDK, the Go SDK has **no per-principal read-only caching** — there +is no `Principal` parameter you can add to a method and no automatic +`Cache-Control: private` / `Vary` switch. Read-only results are cached +per `(method, input)` and shared across callers. If you need per-caller isolation, +model it explicitly (e.g. include the caller identity in the method input) rather +than expecting the runtime to derive it. + +## Key Constraints + +- `golem.ReadOnly(...)` is a per-method option in the **definition** package; an + agent freely mixes read-only and regular methods. +- Cache policy is only expressible via `golem.ReadOnly(...)`; a regular method + cannot carry one. +- Read-only is only valid on **Durable** agents. +- Pass **at most one** cache policy; the default is `golem.CacheUntilWrite()`. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-configure-durability-go`](/next/how-to-guides/go/golem-configure-durability-go) | Read-only requires a durable agent; configure durability/snapshots | +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Expose a read-only method as a cacheable GET/HEAD endpoint | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Read-only methods cannot RPC; fan out from a regular method | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent and its methods | diff --git a/docs/src/content/next/how-to-guides/go/golem-multi-instance-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-multi-instance-agent-go.mdx new file mode 100644 index 0000000000..57a279815a --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-multi-instance-agent-go.mdx @@ -0,0 +1,71 @@ +# Multiple Instances of a Go Agent + +## Overview + +An agent *type* has many *instances*, each identified by its **`ID`** (the constructor parameters). `Agent.Get(id)` returns a client for the durable instance with that id — **two `Get`s with the same id address the same agent**, created implicitly on first invocation. For one-off/ephemeral work use `Agent.NewPhantom(id)`, which allocates a fresh, non-persistent instance. + +## Identity: single or composite + +The `ID` struct's fields are the identity — use several fields for a composite key: + +```go +package session + +import "github.com/golemcloud/golem/sdks/go/golem" + +// One session instance per (user, device). +type ID struct { + User string + Device string +} + +var Agent = golem.DefineAgent[ID](golem.Spec{Name: "SessionAgent", Description: "Per-user, per-device session"}) + +var Touch = golem.DefineMethod[ID, golem.Unit, int64]("touch", golem.Desc("Record activity, return hit count")) +``` + +## Addressing a specific instance + +```go +// Durable instance for this (user, device) — same id always maps to the same agent. +c := session.Agent.Get(session.ID{User: "alice", Device: "laptop"}) +hits := session.Touch.Call(c, golem.Unit{}) +``` + +Iterate ids to address many instances: + +```go +for _, u := range users { + c := session.Agent.Get(session.ID{User: u, Device: "web"}) + session.Touch.Trigger(c, golem.Unit{}) // fan out +} +``` + +## Ephemeral (phantom) instances + +`NewPhantom(id)` allocates a **fresh** instance with no durable identity — the right choice for throwaway/per-request work, and the only way to get a client for an ephemeral agent: + +```go +c := session.Agent.NewPhantom(session.ID{User: "alice", Device: "kiosk"}) +session.Touch.Call(c, golem.Unit{}) + +// To reach the SAME phantom again later, capture and reuse its id: +if pid, ok := c.PhantomID().Get(); ok { // PhantomID() is Option[UUID] + c2 := session.Agent.Get(session.ID{User: "alice", Device: "kiosk"}, + golem.WithPhantomID(pid)) // same phantom instance + _ = c2 +} +``` + +## Key Constraints + +- The `ID` fields *are* the identity: same values → same agent; different values → different agent. There is no separate "create" step. +- Instances are **durable by default**; use `NewPhantom` for ephemeral ones. A phantom's id lives only on its client — capture `Client.PhantomID()` if you need to re-address it. +- Over HTTP, each `ID` field must appear as a `{var}` in the mount path so a URL selects the instance (see [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go)). + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent type and its `ID` | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Call a specific instance from another agent | +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Select an instance from a request URL | diff --git a/docs/src/content/next/how-to-guides/go/golem-parallel-workers-go.mdx b/docs/src/content/next/how-to-guides/go/golem-parallel-workers-go.mdx new file mode 100644 index 0000000000..2523c50f29 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-parallel-workers-go.mdx @@ -0,0 +1,151 @@ +# Parallel Workers — Fan-Out / Fan-In (Go) + +## Overview + +A single Golem agent processes invocations **sequentially** — it cannot run work in parallel by itself. To execute work concurrently, distribute it across **multiple agent instances** and have them run at the same time. The Go SDK gives you two building blocks: + +1. **`CallAsync` + `Future.Get`** — start several cross-agent calls at once, then await each. This is the SDK's only source of concurrency: `Call` (synchronous `invoke-and-await`) blocks the whole component, whereas `Future.Get` is async, so a goroutine blocked in it yields to the component-model event loop and lets the other in-flight calls proceed. +2. **`Trigger` + promises** — fire-and-forget each worker, hand each a promise ID, then await all the promises. Best for long-running work where you don't want a call in flight the whole time. + +> **Platform contract:** a single target instance handles one invocation at a time. Concurrency comes from fanning out to **different** target instances (distinct `ID`s), not from calling the same instance repeatedly. + +> **No `fork`:** the Rust SDK's `fork()` has no equivalent in the current Go SDK. Achieve parallelism by addressing multiple worker instances by `ID` as shown below. + +## Approach 1: async fan-out with `CallAsync` / `Future.Get` + +Start every worker call with `CallAsync`, collect the `*golem.Future[Out]` values in a slice, then `Get()` each. All calls are in flight while you await. + +### Worker definition (`agents/worker/worker.go`) + +```go +package worker + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID identifies a worker instance — distinct IDs run in parallel. +type ID struct{ Index int64 } + +type ProcessIn struct{ Item string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "WorkerAgent", + Description: "Processes one item", +}) + +var Process = golem.DefineMethod[ID, ProcessIn, string]("process", + golem.Desc("Process a single item and return the result")) +``` + +### Coordinator fan-out (`agents/coordinator/impl/impl.go`) + +```go +package impl + +import ( + "myapp/agents/coordinator" + "myapp/agents/worker" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(coordinator.Agent, func(coordinator.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, coordinator.FanOut, func(_ *golem.Context[state], in coordinator.FanOutIn) []string { + // 1. Start every call — each returns immediately with a future. + futures := make([]*golem.Future[string], len(in.Items)) + for i, item := range in.Items { + // A distinct worker instance per item → they run concurrently. + c := worker.Agent.Get(worker.ID{Index: int64(i)}) + futures[i] = worker.Process.CallAsync(c, worker.ProcessIn{Item: item}) + } + + // 2. Await each. All calls were already in flight, so this fans in. + results := make([]string, len(futures)) + for i, f := range futures { + results[i] = f.Get() // Get() blocks (and yields) for this one result + } + return results + }) +} +``` + +`Future.Get` is **fail-loud**: an infra failure (a `golem.RemoteCallError`) traps and surfaces as an agent-error. Model *expected* per-item outcomes as a `golem.Result` in the worker method's output instead, then unwrap or inspect each result: + +```go +// worker.Process returns golem.Result[string, string] +res := futures[i].Get() // golem.Result[string, string] +if res.IsErr() { + failures = append(failures, res.Err()) +} else { + successes = append(successes, res.Ok()) +} +``` + +## Approach 2: fire-and-forget with promise collection + +For long-running work, `Trigger` each worker (fire-and-forget, no call held open) and pass each a promise ID; the worker completes its promise when done, and the coordinator awaits them all. + +### Coordinator + +```go +golem.Handle(agent, coordinator.DispatchAndCollect, func(ctx *golem.Context[state], in coordinator.RegionsIn) []string { + // One promise per worker. + promises := make([]*golem.Promise[string], len(in.Regions)) + for i := range in.Regions { + promises[i] = golem.NewPromise[string]() + } + + // Fire-and-forget: hand each worker its region and its promise id. + for i, region := range in.Regions { + c := worker.Agent.Get(worker.ID{Region: region}) + worker.RunReport.Trigger(c, worker.RunReportIn{Promise: promises[i].ID()}) + } + + // Await all promises (each durably suspends until its worker completes it). + results := make([]string, len(promises)) + for i, p := range promises { + results[i] = p.Await() + } + return results +}) +``` + +### Worker completes its promise + +```go +golem.Handle(agent, worker.RunReport, func(ctx *golem.Context[state], in worker.RunReportIn) golem.Unit { + report := "Report for " + ctx.State.region + ": OK" + golem.CompletePromise(in.Promise, report) + return golem.Unit{} +}) +``` + +`Trigger` returns a `golem.InvocationID` and does not wait; a failure after the invocation is accepted is not reported at the trigger site — the worker signals completion (or failure) through its promise. + +## When to use which + +| Criteria | `CallAsync` / `Future` | `Trigger` + promises | +|----------|------------------------|----------------------| +| Short calls, want results inline | ✅ Best fit | Works but heavier | +| Long-running work, don't hold a call open | ⚠️ Call stays in flight | ✅ Best fit | +| Need the invocation identity for other work | `Future.ID` | `Trigger` returns `InvocationID` | +| Per-item error as a value | Return `golem.Result` in the method | Encode outcome in the promise payload | + +## Key Constraints + +- **No threads within an agent.** Parallelism comes from distributing across distinct worker instances (distinct `ID`s); fanning out to the *same* instance serializes. +- Don't hold a `*golem.Future` across invocations — start it and `Get()` it within the same handler. `Get` consumes the future (a second `Get` panics). +- `Future.Get` and `Promise.Await` are fail-loud; model expected outcomes as a `golem.Result` in the method output, not as a trap. +- Avoid a **synchronous** cycle: two agents each blocking in `Call` on the other deadlocks. Break cycles with `Trigger` / promises. +- Worker instances persist after the coordinator finishes (they are durable by default); give them stable IDs you can address again, or make them ephemeral (see [`golem-stateless-agent-go`](/next/how-to-guides/go/golem-stateless-agent-go)). + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | The synchronous / async call mechanics (`Call`, `CallAsync`) | +| [`golem-fire-and-forget-go`](/next/how-to-guides/go/golem-fire-and-forget-go) | `Trigger` details for fire-and-forget dispatch | +| [`golem-wait-for-external-input-go`](/next/how-to-guides/go/golem-wait-for-external-input-go) | Promises used to collect worker results | +| [`golem-multi-instance-agent-go`](/next/how-to-guides/go/golem-multi-instance-agent-go) | Address many worker instances by `ID` (and phantoms) | diff --git a/docs/src/content/next/how-to-guides/go/golem-recurring-task-go.mdx b/docs/src/content/next/how-to-guides/go/golem-recurring-task-go.mdx new file mode 100644 index 0000000000..bc01540bde --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-recurring-task-go.mdx @@ -0,0 +1,92 @@ +# Recurring & Scheduled Tasks in Go + +## Overview + +A recurring task is a method that **reschedules itself**: it does its work, then schedules the next run. Scheduling uses `Method.Schedule(client, at, in)`, which arranges an invocation at a future time and returns a cancelable `*golem.ScheduledInvocation`. + +To message itself an agent needs a client for its **own** instance, which needs its own `ID`. `Context` only exposes the raw id string, so **capture the typed `ID` in state at construction** — the constructor passed to `golem.Implement` receives it. + +## Steps + +1. **Capture the agent's own `ID` in state** in the `Implement` constructor. +2. **Add a tick method** that does the work and then `Schedule`s itself for the next run. +3. **Start the loop** — a `Start` method (or an external trigger) schedules the first tick. + +## Example + +Definition (`agents/poller/poller.go`): + +```go +package poller + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{Name: "PollerAgent", Description: "Periodic poller"}) + +var ( + Start = golem.DefineMethod[ID, golem.Unit, golem.Unit]("start", golem.Desc("Begin the recurring loop")) + Tick = golem.DefineMethod[ID, golem.Unit, golem.Unit]("tick", golem.Desc("One iteration; reschedules itself")) +) +``` + +Implementation (`agents/poller/impl/impl.go`): + +```go +package impl + +import ( + "time" + + "myapp/agents/poller" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +const interval = time.Minute + +// state stashes the agent's own ID so it can build a client to itself. +type state struct{ self poller.ID } + +// The constructor receives this instance's ID — capture it. +var agent = golem.Implement(poller.Agent, func(id poller.ID) *state { return &state{self: id} }) + +func init() { + golem.Handle(agent, poller.Start, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + self := poller.Agent.Get(ctx.State.self) + poller.Tick.Schedule(self, time.Now().Add(interval), golem.Unit{}) + return golem.Unit{} + }) + + golem.Handle(agent, poller.Tick, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + // ... do the periodic work ... + + // schedule the next iteration + self := poller.Agent.Get(ctx.State.self) + poller.Tick.Schedule(self, time.Now().Add(interval), golem.Unit{}) + return golem.Unit{} + }) +} +``` + +Kick off the loop by invoking `start` once (from the CLI, an HTTP endpoint, or another agent). + +## Scheduling vs immediate self-messaging + +- `Schedule(client, at, in) *ScheduledInvocation` — run at a future `time.Time`. Keep the handle to cancel it: `inv.Cancel()`. +- `Trigger(client, in)` — enqueue immediately, no delay (use it to advance a state machine to the next step now). +- **Never self-`Call`** — a synchronous call into the same instance deadlocks (one instance processes one invocation at a time). Self-messaging must use `Trigger` or `Schedule`. + +## Key Constraints + +- The self `ID` must come from the constructor (or be reconstructable) — `Context` exposes only `AgentID() string`, not the typed `ID`. +- The reschedule must live in the tick handler itself (a package-level descriptor referencing its own handler in an `init()` is fine; there is no var-initialization cycle because the handler is registered in `init`, not in a `var` initializer). +- Compute the next time with `time.Now().Add(interval)`; the scheduled time is recorded durably. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-fire-and-forget-go`](/next/how-to-guides/go/golem-fire-and-forget-go) | Enqueue an immediate invocation (`Trigger`) | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Await a result from another agent | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent | diff --git a/docs/src/content/next/how-to-guides/go/golem-retry-policies-go.mdx b/docs/src/content/next/how-to-guides/go/golem-retry-policies-go.mdx new file mode 100644 index 0000000000..997bd63fb0 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-retry-policies-go.mdx @@ -0,0 +1,293 @@ +# Configuring Semantic Retry Policies (Go) + +Golem retries retriable operations (RPC, HTTP, RDBMS, and whole-invocation traps) +according to **named policy rules**. Each rule is a `retry.NamedPolicy`: a +`retry.Policy` (the strategy) plus a `retry.Predicate` deciding when it applies and +a priority. Per operation, the runtime resolves the highest-priority rule whose +predicate matches and applies its policy. + +Rules come from three tiers, and the Go `retry` subpackage +(`github.com/golemcloud/golem/sdks/go/golem/retry`) works with all of them: + +- **Manifest** (`golem.yaml`) or CLI — operator-tuned base rules; the code reads + them back. +- **Code-owned** — `retry.Set(...)` registers a rule that persists for the agent. +- **Per-call** — `retry.With(...)` overrides a rule for one call, restored on return. + +## Steps + +1. **Declare base rules** in `golem.yaml` (`retryPolicyDefaults`), scoped per environment. +2. **Build strategies in code** from a base policy plus fluent combinators. +3. **Apply** them: `retry.Set` for code-owned rules (often in the constructor), `retry.With` for per-call overrides. +4. **Query** active rules with `retry.GetByName` / `retry.GetPolicies` / `retry.PolicyNames`. + +## 1. Define Retry Policies in the Application Manifest + +Add definitions under `retryPolicyDefaults` in `golem.yaml`, scoped per +environment. This is platform-level config (shared with the other language SDKs): + +```yaml +retryPolicyDefaults: + prod: + http-transient: + priority: 10 + predicate: + and: + - propEq: { property: "error-type", value: "transient" } + - propEq: { property: "uri-scheme", value: "https" } + policy: + countBox: + maxRetries: 5 + inner: + jitter: + factor: 0.15 + inner: + clamp: + minDelay: "100ms" + maxDelay: "5s" + inner: + exponential: + baseDelay: "200ms" + factor: 2.0 + catch-all: + priority: 0 + predicate: true + policy: + countBox: + maxRetries: 3 + inner: + exponential: + baseDelay: "100ms" + factor: 3.0 +``` + +Policies are evaluated in **descending priority order**; the first matching +predicate's policy wins. If none match, the built-in `default` (3 retries, +exponential backoff, clamped to [100ms, 1s], 15% jitter) applies. + +## 2. Build and Apply Policies in Code + +Use the `retry` subpackage. A `Policy`/`Predicate`/`NamedPolicy` is an **immutable +value**; combinators return a new value, so malformed graphs are unrepresentable. + +```go +import ( + "time" + + "github.com/golemcloud/golem/sdks/go/golem/retry" +) + +pol := retry.Exponential(200*time.Millisecond, 2.0). + Clamp(100*time.Millisecond, 5*time.Second). + WithJitter(0.15). + OnlyWhen(retry.ErrorType.Eq("transient")). + MaxRetries(5) + +rule := retry.Named("http-transient", pol). + WithPriority(10). + AppliesWhen(retry.URIScheme.Eq("https")) +``` + +### Base policies + +| Constructor | Description | +|---|---| +| `retry.Periodic(d)` | Fixed delay between attempts | +| `retry.Exponential(base, factor)` | `base × factor^attempt` — exponentially growing delays (factor finite, > 0) | +| `retry.Fibonacci(first, second)` | Fibonacci-growing delay seeded by `first`, `second` | +| `retry.Immediate()` | Retry with no delay | +| `retry.Never()` | Do not retry | + +### Combinators (methods on `Policy`) + +| Method | Description | +|---|---| +| `.MaxRetries(n)` | Cap the number of retries | +| `.Within(d)` | Stop retrying once a wall-clock budget elapses | +| `.Clamp(minD, maxD)` | Bound each computed delay to `[minD, maxD]` (`minD <= maxD`) | +| `.AddDelay(d)` | Add a fixed offset to each delay | +| `.WithJitter(factor)` | Randomize each delay by up to `factor` (finite, >= 0) | +| `.OnlyWhen(pred)` | Apply the strategy only when `pred` matches; otherwise give up | +| `.AndThen(next)` | Fall back to `next` once this policy stops retrying | +| `.Union(other)` | Retry if either would retry (shorter delay wins) | +| `.Intersect(other)` | Retry only if both would retry (longer delay wins) | + +```go +// Exponential, clamped, jittered, capped: +retry.Exponential(200*time.Millisecond, 2.0). + Clamp(100*time.Millisecond, 5*time.Second). + WithJitter(0.15). + MaxRetries(5) + +// Periodic with a wall-clock budget: +retry.Periodic(time.Second).Within(60 * time.Second) + +// Immediate retries, then fall back to exponential: +retry.Immediate().MaxRetries(3). + AndThen(retry.Exponential(time.Second, 2.0).MaxRetries(5)) + +// Never retry: +retry.Never() +``` + +### Predicates + +Build a predicate from a property (`retry.PropName`) using a comparison method, +then compose with `.And` / `.Or` / `.Not`: + +```go +// A property comparison: +retry.ErrorType.Eq("transient") +retry.StatusCode.OneOf(500, 502, 503, 504) + +// Compose: +retry.ErrorType.Eq("transient").And(retry.URIScheme.Eq("https")) + +// Always / never: +retry.MatchAlways() +retry.MatchNever() +``` + +`PropName` comparison methods: `.Eq`, `.Neq`, `.Gt`, `.Gte`, `.Lt`, `.Lte`, +`.Exists()`, `.OneOf(...)`, `.MatchesGlob(pat)`, `.StartsWith(prefix)`, +`.Contains(sub)`. Comparison values may be a string, any integer type, or a bool. + +### Available properties + +Exported `retry.PropName` constants (use `retry.Prop("name")` for any other): + +| Constant | Populated in | +|---|---| +| `retry.Verb` | every context (HTTP method, RDBMS/RPC verb, or `"trap"`) | +| `retry.NounURI`, `retry.URIScheme`, `retry.URIHost`, `retry.URIPort`, `retry.URIPath` | every context (decomposed resource URI) | +| `retry.StatusCode` | outgoing HTTP **response** only | +| `retry.ErrorType` | outgoing HTTP **response** only (`"transient"`, `"http-status"`) | +| `retry.Function` | worker-to-worker RPC call | +| `retry.TargetComponentID`, `retry.TargetAgentType` | worker-to-worker RPC call | +| `retry.DBType` | RDBMS operations (`postgres`, `mysql`, …) | +| `retry.TrapType` | guest WASM trap (`transient-error`, `unknown`, …) | + +A policy keyed on a property **not present in the current context is silently +skipped** for that decision. So a `StatusCode`-keyed policy fires only for HTTP +responses, a `TrapType`-keyed policy only from the trap path — design one policy +per context (or use `.Or`/`.And` to match several) rather than expecting one policy +to cover everything. + +### Apply: `Set` (code-owned) and `With` (per-call) + +`retry.Set` registers/overwrites a rule and **persists** it for the agent (it +takes precedence over a manifest/CLI rule of the same name). Reach for it when the +code owns the rule — often in the constructor. Both `Set` and `With` **panic** on +an invalid policy (check first with `NamedPolicy.Validate()`). + +```go +var codeOwned = retry.Named("code-owned", + retry.Exponential(100*time.Millisecond, 2.0). + Clamp(50*time.Millisecond, 2*time.Second). + OnlyWhen(retry.StatusCode.Gte(500)). + MaxRetries(4)). + WithPriority(20). + AppliesWhen(retry.TargetAgentType.Eq("InventoryAgent")) + +var agent = golem.Implement(retrying.Agent, func(retrying.ID) *state { + retry.Set(codeOwned) // register the code-owned rule when the worker starts + return &state{} +}) +``` + +`retry.With` applies a rule for the **current call only** and returns a `restore` +function that reinstates the previously registered rule (or removes it) — scope it +with `defer`: + +```go +golem.Handle(agent, retrying.Burst, func(_ *golem.Context[state], _ golem.Unit) retrying.Snapshot { + // Override the code-owned rule just for this call, restored on return. + defer retry.With(retry.Named("code-owned", retry.Immediate().MaxRetries(10)). + WithPriority(99). + AppliesWhen(retry.TargetAgentType.Eq("InventoryAgent")))() + return doWork() +}) +``` + +`retry.Remove(name)` deletes a rule. + +> **Concurrency.** `Set`, `Remove`, and `With` apply at the **worker level**, not +> per goroutine. `With` is safe as long as its scope does not await while other +> goroutines run concurrently; don't hold an override open across a `CallAsync` +> fan-out. + +## 3. Query Policies at Runtime + +```go +// Names only (cheap — does not decode bodies): +names := retry.PolicyNames() + +// Fully decoded rules: +policies, err := retry.GetPolicies() +if err == nil { + for _, p := range policies { + _ = p.Name() // string + _ = p.Priority() // uint32 + } +} + +// A specific rule by name: +np, found, err := retry.GetByName("http-transient") +if err == nil && found { + _ = np.Priority() +} + +// What policy the runtime would pick for a hypothetical operation: +pol, matched, err := retry.Resolve("GET", "https://api.example.com/x", + map[string]any{"status-code": 503}) +_ = pol +_ = matched +_ = err +``` + +`NamedPolicy` accessors: `.Name()`, `.Priority()`, `.Strategy()` (opaque `Policy`), +`.Applicability()` (`Predicate`), and `.Validate()` (returns the first lowering +error, or nil). + +## 4. Live-Editing Policies via CLI + +Retry policies can be managed at runtime without redeployment (takes effect +immediately for running agents): + +```shell +golem retry-policy create http-transient \ + --priority 10 \ + --predicate '{ "and": [{ "propEq": { "property": "error-type", "value": "transient" } }, { "propEq": { "property": "uri-scheme", "value": "https" } }] }' \ + --policy '{ "countBox": { "maxRetries": 5, "inner": { "exponential": { "baseDelay": "200ms", "factor": 2.0 } } } }' + +golem retry-policy list +golem retry-policy get http-transient +golem retry-policy update http-transient --priority 15 +golem retry-policy delete http-transient +``` + +## 5. Default Retry Policy + +When no user-defined policy matches, Golem uses the built-in `default`: priority +`0`, predicate `true`, up to 3 retries, exponential backoff (factor 3.0), delays +clamped to [100ms, 1s], 15% jitter. + +## Key Constraints + +- `Policy`/`Predicate`/`NamedPolicy` are immutable values; combinators return new + values (build once as package data where possible). +- `retry.Set` and `retry.With` **panic** on an invalid policy — validate first with + `NamedPolicy.Validate()` if the inputs are dynamic. +- Policies are defined **per-environment**; names must be unique within one; higher + priority is evaluated first. +- A property-keyed policy is silently skipped in a context that lacks that property. +- `retry.With` is scoped to the current call — the previous rule is restored on + return; it is worker-global, so mind concurrent awaits. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-make-http-request-go`](/next/how-to-guides/go/golem-make-http-request-go) | The outgoing HTTP calls whose responses drive status-code retries | +| [`golem-atomic-block-go`](/next/how-to-guides/go/golem-atomic-block-go) | Idempotence mode and atomic regions interact with retry semantics | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | RPC calls retried via `Function` / `TargetAgentType`-keyed rules | +| [`golem-add-transactions-go`](/next/how-to-guides/go/golem-add-transactions-go) | Saga transactions layered on durable execution and retries | diff --git a/docs/src/content/next/how-to-guides/go/golem-schedule-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-schedule-agent-go.mdx new file mode 100644 index 0000000000..6599ca5119 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-schedule-agent-go.mdx @@ -0,0 +1,94 @@ +# Scheduling a Future Agent Invocation from the CLI + +## Overview + +The `--schedule-at` flag on `golem agent invoke` schedules the invocation to execute at a specific future time. It **requires** the `--trigger` flag, because scheduled invocations are always fire-and-forget — the CLI returns immediately after the invocation is enqueued, and the Golem runtime executes it when the scheduled time arrives. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Pick the method** and any arguments (e.g. `increment`, `add 5`). +3. **Choose the time** in ISO 8601 / RFC 3339 format with a timezone. +4. **Run `golem agent invoke --trigger --schedule-at `** — the CLI returns immediately. + +## Usage + +```shell +golem agent invoke --trigger --schedule-at [ARGUMENTS...] +``` + +## DateTime Format + +The `--schedule-at` value must be in **ISO 8601 / RFC 3339** format with a timezone: + +``` +2026-03-15T10:30:00Z # UTC +2026-03-15T10:30:00+02:00 # With timezone offset +``` + +## Examples + +### Schedule a method to run at a specific time + +```shell +golem agent invoke --trigger --schedule-at 2026-03-15T10:30:00Z 'CounterAgent("my-counter")' increment +``` + +### Schedule with an argument + +```shell +golem agent invoke --trigger --schedule-at 2026-04-01T00:00:00Z 'CounterAgent("my-counter")' add 5 +``` + +### Schedule in a specific environment + +```shell +golem agent invoke --trigger --schedule-at 2026-03-15T08:00:00Z 'production/CounterAgent("my-counter")' increment +``` + +### Schedule with an idempotency key for deduplication + +```shell +golem agent invoke --trigger --schedule-at 2026-03-15T10:30:00Z -i 'increment-2026-03-15' 'CounterAgent("my-counter")' increment +``` + +## Available Options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | **Required** with `--schedule-at`. Fire-and-forget mode | +| `--schedule-at ` | The time to execute the invocation (ISO 8601 / RFC 3339) | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | + +## How It Works + +1. The CLI sends the invocation request with the scheduled time to the Golem server. +2. The server enqueues the invocation to execute at the specified time. +3. The CLI returns immediately with the idempotency key. +4. At the scheduled time, the Golem runtime executes the invocation. + +## Value Syntax + +Agent ID parameters and method arguments use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- `--schedule-at` requires `--trigger`; a scheduled invocation is always fire-and-forget. +- The datetime must include a timezone (RFC 3339); use `Z` for UTC. +- Scheduled invocations use idempotency keys just like regular invocations — the same key is not executed more than once. +- To schedule a future call from **inside agent code** (rather than the CLI), use `Method.Schedule` — see [`golem-schedule-future-call-go`](/next/how-to-guides/go/golem-schedule-future-call-go). + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-schedule-future-call-go`](/next/how-to-guides/go/golem-schedule-future-call-go) | Schedule a future call from *agent code* (`Method.Schedule`) | +| [`golem-trigger-agent-go`](/next/how-to-guides/go/golem-trigger-agent-go) | Fire-and-forget invocation without a schedule | +| [`golem-invoke-agent-go`](/next/how-to-guides/go/golem-invoke-agent-go) | Synchronous invocation that waits for the result | +| [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go) | A self-rescheduling / periodic task in agent code | diff --git a/docs/src/content/next/how-to-guides/go/golem-schedule-future-call-go.mdx b/docs/src/content/next/how-to-guides/go/golem-schedule-future-call-go.mdx new file mode 100644 index 0000000000..576284011a --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-schedule-future-call-go.mdx @@ -0,0 +1,103 @@ +# Scheduling a Future Agent Call from Go Code + +## Overview + +`Method.Schedule(client, at, in)` enqueues a **one-off** invocation of a method to run at a specific future time. It returns a `*golem.ScheduledInvocation`, whose `Cancel()` prevents the invocation if it has not started yet. + +Like `Trigger`, `Schedule` does not wait for a result — so it is safe to target **another** agent or the **same** instance (a synchronous self-`Call` would deadlock). The scheduled time is recorded durably and survives restarts. + +For a task that **reschedules itself** on an interval (a periodic / cron-like loop), see [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go); this skill covers scheduling a single future call and canceling it. + +## Steps + +1. **Get a client** for the target instance: `counter.Agent.Get(counter.ID{Name: "my-counter"})`. +2. **Schedule the method** at a `time.Time`: `counter.Increment.Schedule(c, when, in)`. +3. **Keep the returned `*golem.ScheduledInvocation`** if you may need to cancel it. +4. **Cancel** with `inv.Cancel()` before the scheduled time to prevent it. + +## Scheduling a future call on another agent + +```go +package impl + +import ( + "time" + + "myapp/agents/counter" + "myapp/agents/scheduler" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ pending *golem.ScheduledInvocation } + +var agent = golem.Implement(scheduler.Agent, func(scheduler.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, scheduler.Arm, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + c := counter.Agent.Get(counter.ID{Name: "my-counter"}) + // Run counter.increment 60 seconds from now. + ctx.State.pending = counter.Increment.Schedule(c, time.Now().Add(60*time.Second), golem.Unit{}) + return golem.Unit{} + }) +} +``` + +`Schedule` returns a `*golem.ScheduledInvocation`; its `ID` field is the invocation's `InvocationID`. + +### Scheduling a method that takes arguments + +Pass the method's input value as the last argument, exactly as with `Call` / `Trigger`: + +```go +c := counter.Agent.Get(counter.ID{Name: "my-counter"}) +counter.Add.Schedule(c, time.Now().Add(24*time.Hour), counter.AddIn{By: 5}) +``` + +## Canceling a scheduled call + +Keep the `*golem.ScheduledInvocation` (e.g. in state) and call `Cancel()`: + +```go +func init() { + golem.Handle(agent, scheduler.Cancel, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + if ctx.State.pending != nil { + ctx.State.pending.Cancel() // no-op if it has already started + ctx.State.pending = nil + } + return golem.Unit{} + }) +} +``` + +`Cancel()` is idempotent: it does nothing if already canceled, and cannot un-run an invocation that has already started. + +## Scheduling a future call to itself + +To message its own instance an agent needs a client for its own `ID`. `Context` exposes only the id string, so capture the typed `ID` in state at construction (see [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go) for the full pattern): + +```go +self := counter.Agent.Get(ctx.State.self) // ctx.State.self captured in the constructor +counter.Increment.Schedule(self, time.Now().Add(time.Minute), golem.Unit{}) +``` + +## Schedule vs Trigger + +- `Schedule(c, at, in) *ScheduledInvocation` — run once at a future `time.Time`; cancelable via `Cancel()`. +- `Trigger(c, in) InvocationID` — enqueue immediately, no delay, not cancelable. Use it to advance to the next step now. +- Never self-`Call` — a synchronous call into the same instance deadlocks; self-messaging must use `Schedule` or `Trigger`. + +## Key Constraints + +- `Schedule` / `Trigger` are called on the **method descriptor** (`counter.Increment.Schedule(c, ...)`), and the client comes from the callee's **definition** (`counter.Agent.Get(id)`). +- Compute the time with `time.Now().Add(d)` (a `time.Time`); it is recorded durably. +- To cancel later, you must retain the `*golem.ScheduledInvocation` — don't discard it if cancellation may be needed. Hold it in agent state, not across a bare `var` initializer. +- For a self-scheduling recurring loop, don't hand-roll it here — use [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go). + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-recurring-task-go`](/next/how-to-guides/go/golem-recurring-task-go) | A self-rescheduling / periodic (cron-like) task | +| [`golem-fire-and-forget-go`](/next/how-to-guides/go/golem-fire-and-forget-go) | Enqueue an immediate invocation (`Trigger`) | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | Await a result from another agent (`Call` / `CallAsync`) | +| [`golem-schedule-agent-go`](/next/how-to-guides/go/golem-schedule-agent-go) | Schedule a future invocation from the CLI | diff --git a/docs/src/content/next/how-to-guides/go/golem-stateless-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-stateless-agent-go.mdx new file mode 100644 index 0000000000..4cad2a2406 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-stateless-agent-go.mdx @@ -0,0 +1,135 @@ +# Creating Ephemeral (Stateless) Agents (Go) + +## Overview + +An **ephemeral agent** gets a **fresh instance for every invocation**. Unlike the default durable agents, an ephemeral agent: + +- **Has no shared state** — each invocation starts from a clean init function; values set in one call are gone by the next. +- **Is not replayed** — an oplog is still recorded lazily (inspectable via `golem agent oplog`), but it is never used to replay/recover. +- **Discards its memory** after each invocation completes. +- **Keeps the same identity model** — still addressed by its constructor parameters (`ID`), but every call behaves as if the agent was just created. + +This fits **pure request handlers**, **stateless transformers**, **adapters**, and **serverless-style functions** where each call is independent. + +## How to make an agent ephemeral + +Set `Mode: golem.Ephemeral` on the `Spec`. `Mode` defaults to `golem.Durable`. + +```go +// Package handler is the DEFINITION of a stateless request-handler agent. +package handler + +import "github.com/golemcloud/golem/sdks/go/golem" + +// An ID with no fields is a singleton identity; add fields to address variants. +type ID struct{} + +type HandleIn struct{ Input string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "RequestHandlerAgent", + Description: "Stateless request handler — fresh instance per invocation", + Mode: golem.Ephemeral, // <- makes every invocation start clean +}) + +var Handle = golem.DefineMethod[ID, HandleIn, string]("handle", + golem.Desc("Process one request and return the result")) +``` + +### Implementation + +The implementation is written exactly like a durable agent's — the `state` type just holds nothing meaningful across calls (or is empty), because it is recreated each invocation: + +```go +package impl + +import ( + "strings" + + "myapp/agents/handler" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state is empty: an ephemeral agent keeps nothing between invocations. +type state struct{} + +var agent = golem.Implement(handler.Agent, func(handler.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, handler.Handle, func(_ *golem.Context[state], in handler.HandleIn) string { + return "processed: " + strings.ToUpper(in.Input) + }) +} +``` + +## What "fresh instance per invocation" means + +The only difference from a durable agent is `Mode`: + +```go +// DURABLE (default) — state accumulates across calls. +var Durable = golem.DefineAgent[ID](golem.Spec{Name: "DurableCounter"}) +// increment() three times → 1, 2, 3 + +// EPHEMERAL — state resets every call. +var Ephemeral = golem.DefineAgent[ID](golem.Spec{Name: "EphemeralCounter", Mode: golem.Ephemeral}) +// increment() three times → 1, 1, 1 +``` + +Each invocation of an ephemeral agent: +1. Runs the init function (`func(ID) *state`) to build a fresh state. +2. Executes the method handler. +3. Discards the instance entirely. + +## Combining with HTTP endpoints + +Ephemeral agents are a natural fit for HTTP request handlers — declare an HTTP mount alongside `Mode: golem.Ephemeral`: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ConverterAgent", + Mode: golem.Ephemeral, + HTTP: &golem.Mount{Path: "/api/convert/{name}"}, +}) + +var ( + ToUpper = golem.DefineMethod[ID, ConvertIn, string]("toUpper", + golem.HTTP(golem.POST("/to-upper"))) + ToLower = golem.DefineMethod[ID, ConvertIn, string]("toLower", + golem.HTTP(golem.POST("/to-lower"))) +) +``` + +## When to use ephemeral agents + +| Use case | Why ephemeral | +|----------|---------------| +| Stateless HTTP API (REST adapter, proxy) | No state to persist between requests | +| Data transformation / format conversion | Pure function — input in, output out | +| Validation service | Each validation is independent | +| Webhook receiver that forwards events | No need to remember previous events | +| Stateless computation (math, encoding) | No side effects worth persisting | + +## When NOT to use ephemeral agents + +- **Counters, accumulators, shopping carts** — need state across calls → use durable (default). +- **Workflow orchestrators, sagas** — need the oplog for recovery → use durable (default). +- **Agents where at-least-once semantics on external effects matter** → use durable (default). +- **Any agent where one call's result depends on a previous call** → use durable (default). + +## Key Constraints + +- Ephemeral mode is set at the **agent type level** (`Spec.Mode`) — all instances of the type are ephemeral. +- Constructor parameters still define identity — different `ID` values are still distinct addressable agents. +- Ephemeral agents can still call other agents (RPC), make HTTP requests, and use the rest of the SDK — they simply don't retain state or replay. +- The oplog is recorded lazily (inspectable via `golem agent oplog`) but is never replayed for recovery. +- State-only durability features (snapshotting, atomic blocks over persisted state) have nothing to persist here; leave `Spec.Snapshot` at its default. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent and its methods (durable baseline) | +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Expose the stateless agent over HTTP | +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | An ephemeral agent calling other agents | +| [`golem-configure-durability-go`](/next/how-to-guides/go/golem-configure-durability-go) | Durability controls for the durable alternative | diff --git a/docs/src/content/next/how-to-guides/go/golem-trigger-agent-go.mdx b/docs/src/content/next/how-to-guides/go/golem-trigger-agent-go.mdx new file mode 100644 index 0000000000..381d414b83 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-trigger-agent-go.mdx @@ -0,0 +1,94 @@ +# Triggering a Fire-and-Forget Agent Invocation + +## Overview + +The `--trigger` (or `-t`) flag on `golem agent invoke` sends the invocation request to the agent and **returns immediately** without waiting for the result. The invocation is enqueued and executed asynchronously by the Golem runtime. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Pick the method** to enqueue (e.g. `increment`, `add`). +3. **Run `golem agent invoke --trigger`** — the CLI returns as soon as the invocation is accepted. + +## Usage + +```shell +golem agent invoke --trigger [ARGUMENTS...] +``` + +## When to Use Trigger + +- When the caller does not need the return value +- When you want to start a long-running operation without blocking +- When enqueuing work for background processing +- When combined with `--schedule-at` for future execution (see [`golem-schedule-agent-go`](/next/how-to-guides/go/golem-schedule-agent-go)) + +## Examples + +### Trigger a method with no wait + +```shell +golem agent invoke --trigger 'CounterAgent("my-counter")' increment +``` + +### Trigger with an argument + +`add` takes one parameter (the `By` field of `AddIn`), passed positionally: + +```shell +golem agent invoke --trigger 'CounterAgent("my-counter")' add 5 +``` + +### Trigger in a specific environment + +```shell +golem agent invoke --trigger 'staging/CounterAgent("my-counter")' increment +``` + +### Trigger with an explicit idempotency key + +```shell +golem agent invoke --trigger -i 'increment-2026-01-15' 'CounterAgent("my-counter")' increment +``` + +## Available Options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | **Required.** Trigger the invocation without waiting | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | +| `--schedule-at ` | Schedule the invocation at a specific time (ISO 8601 format, e.g. `2026-03-15T10:30:00Z`) | + +## Difference from Regular Invoke + +| | `golem agent invoke` | `golem agent invoke --trigger` | +|---|---|---| +| Waits for result | Yes | No | +| Returns value | Yes | Only the idempotency key | +| Streams output | Yes (by default) | No | +| Use case | Synchronous calls | Fire-and-forget / background work | + +## Value Syntax + +Agent ID parameters and method arguments use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- Triggered invocations still use idempotency keys — the same key is not executed twice. +- There is no way to read a return value from a triggered invocation; use plain `golem agent invoke` when you need the result. +- If the component is not deployed yet and the CLI runs from an application directory, the command auto-builds and deploys it before triggering. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-invoke-agent-go`](/next/how-to-guides/go/golem-invoke-agent-go) | Synchronous invocation that waits for the result | +| [`golem-schedule-agent-go`](/next/how-to-guides/go/golem-schedule-agent-go) | Combine `--trigger` with `--schedule-at` for future execution | +| [`golem-fire-and-forget-go`](/next/how-to-guides/go/golem-fire-and-forget-go) | Fire-and-forget invocation from *agent code* (`Trigger`) | +| [`golem-create-agent-instance-go`](/next/how-to-guides/go/golem-create-agent-instance-go) | Pre-create an agent instance (`golem agent new`) | diff --git a/docs/src/content/next/how-to-guides/go/golem-wait-for-external-input-go.mdx b/docs/src/content/next/how-to-guides/go/golem-wait-for-external-input-go.mdx new file mode 100644 index 0000000000..a1325fc726 --- /dev/null +++ b/docs/src/content/next/how-to-guides/go/golem-wait-for-external-input-go.mdx @@ -0,0 +1,162 @@ +# Waiting for External Input with Golem Promises (Go) + +## Overview + +A **Golem promise** lets an agent suspend its execution until an external event completes it. The agent creates a promise, hands the promise ID to an external system (another agent, a webhook, a UI, an HTTP API call), and then awaits the result. The Golem runtime **durably suspends** the invocation — consuming no resources, surviving restarts, exactly-once via oplog replay — until the promise is fulfilled. + +In Go a promise is a typed handle `golem.Promise[T]`: the completion payload is decoded as `T` via JSON (or passed through unchanged when `T` is `[]byte`). + +## Steps + +1. **Create a promise** inside a handler with `golem.NewPromise[T]()`. +2. **Persist its ID** (`p.ID()`) in the agent's state, and/or hand it to the outside world so someone can complete it later. +3. **Await it** with `golem.PromiseByID[T](id).Await()` (or `p.Await()` in the same invocation) — the invocation durably suspends here. +4. **Complete it** from another agent with `golem.CompletePromise(id, value)`, or from off-platform via the worker REST endpoint / a minted `WebhookURL()`. + +## API (from `promise.go`) + +| Function / Method | Signature | Description | +|-------------------|-----------|-------------| +| `golem.NewPromise[T]` | `func NewPromise[T any]() *Promise[T]` | Create a fresh promise owned by the current agent | +| `golem.PromiseByID[T]` | `func PromiseByID[T any](id PromiseID) *Promise[T]` | Rebuild a handle from a stored `PromiseID` | +| `(*Promise[T]).ID` | `func (p *Promise[T]) ID() PromiseID` | The durable identity to persist or hand out | +| `(*Promise[T]).Await` | `func (p *Promise[T]) Await() T` | Durably block until completed; returns the payload as `T` | +| `(*Promise[T]).WebhookURL` | `func (p *Promise[T]) WebhookURL() string` | Mint an external URL whose POST body completes the promise | +| `golem.CompletePromise[T]` | `func CompletePromise[T any](id PromiseID, value T) bool` | Complete a promise from another agent; returns `false` if already completed | + +`Await` is **fail-loud**: an infra failure traps and surfaces as an agent-error rather than returning an `error`. Only the agent that created the promise may `Await` it — awaiting from another agent traps in the host. + +## `PromiseID` structure + +`golem.PromiseID` has three exported (JSON-marshalable) fields, which are exactly what the REST complete endpoint needs: + +```go +type PromiseID struct { + ComponentID golem.UUID // the component the owning agent belongs to + AgentID string // agent type + constructor params (the ":agent" path segment) + OplogIndex uint64 // disambiguates promises from the same agent ("oplogIdx") +} +``` + +## Full example: human-in-the-loop approval + +### Definition (`agents/approval/approval.go`) + +```go +// Package approval is the DEFINITION of the human-in-the-loop approval agent. +package approval + +import "github.com/golemcloud/golem/sdks/go/golem" + +// Verdict is the promise payload, typed as JSON by golem.Promise. +type Verdict struct { + Approved bool + Reason string +} + +type ID struct{ Queue string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ApprovalAgent", + Description: "Human-in-the-loop approvals via durable promises", +}) + +var ( + // Request opens the promise and returns its id for an external completer. + Request = golem.DefineMethod[ID, golem.Unit, golem.PromiseID]("request", + golem.Desc("Open an approval request, returning the promise id to complete")) + // Await durably blocks until the open request is completed. + Await = golem.DefineMethod[ID, golem.Unit, Verdict]("await", + golem.Desc("Durably block until the open request is completed")) +) +``` + +### Implementation (`agents/approval/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the approval agent. Await durably +// SUSPENDS the invocation until the promise is completed. +package impl + +import ( + "myapp/agents/approval" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state remembers the open promise across invocations. +type state struct { + pending golem.PromiseID + open bool +} + +var agent = golem.Implement(approval.Agent, func(approval.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, approval.Request, func(ctx *golem.Context[state], _ golem.Unit) golem.PromiseID { + p := golem.NewPromise[approval.Verdict]() + ctx.State.pending = p.ID() // persist so a later invocation can Await it + ctx.State.open = true + return p.ID() + }) + + golem.Handle(agent, approval.Await, func(ctx *golem.Context[state], _ golem.Unit) approval.Verdict { + if !ctx.State.open { + panic("no open approval request — call request first") + } + // Rebuild the handle from the stored id and durably suspend until completion. + return golem.PromiseByID[approval.Verdict](ctx.State.pending).Await() + }) +} +``` + +## Completing from another agent + +```go +// From any agent — agent-to-agent completion: +ok := golem.CompletePromise(pendingID, approval.Verdict{Approved: true, Reason: "looks good"}) +_ = ok // false means it was already completed (idempotency signal) +``` + +## Completing from outside Golem (REST) + +Hand the three `PromiseID` fields to the external system; it POSTs to the worker-service complete endpoint: + +```shell +curl -X POST \ + "$GOLEM_URL/v1/components/$COMPONENT_ID/workers/$AGENT_ID/complete" \ + -H 'Content-Type: application/json' \ + -d '{"oplogIdx": , "data": []}' +``` + +The `data` bytes become the payload `Await` decodes as `T` (JSON when `T` is a struct). + +## Webhook-style callback + +When the agent type is HTTP-API-deployed (its `Spec.HTTP` is set and it is declared in the manifest's `httpApi` deployment), mint a URL whose POST body completes the promise: + +```go +p := golem.NewPromise[Event]() +url := p.WebhookURL() // hand this to an off-platform system; its POST body completes the promise +ctx.State.pending = p.ID() +// later, in another invocation: +event := golem.PromiseByID[Event](ctx.State.pending).Await() +``` + +`WebhookURL` is fail-loud: it traps if the agent is not HTTP-API-deployed. + +## Key Constraints + +- The promise payload is typed as `T` via JSON. Use `golem.Promise[[]byte]` as an escape hatch to carry raw, non-JSON bytes through unchanged. +- Only the **creating** agent may `Await` a promise; awaiting from a different agent traps. +- Persist `p.ID()` in the agent's state if the promise is created in one invocation and awaited in another — a single agent processes invocations sequentially, so `Request` returns before `Await` runs. +- `Await` is fail-loud (traps on infra failure), matching Golem's exactly-once model — do not expect an `error` return. +- `CompletePromise` returns `false` if the promise was already completed; treat it as the idempotency signal, not a failure. + +### Related Guides +| Guide | Description | +|-------|--------------| +| [`golem-call-another-agent-go`](/next/how-to-guides/go/golem-call-another-agent-go) | An agent completes another agent's promise via RPC | +| [`golem-parallel-workers-go`](/next/how-to-guides/go/golem-parallel-workers-go) | Fan out work and collect results via promises | +| [`golem-add-http-endpoint-go`](/next/how-to-guides/go/golem-add-http-endpoint-go) | Expose the agent over HTTP so `WebhookURL` works | +| [`golem-add-agent-go`](/next/how-to-guides/go/golem-add-agent-go) | Define the agent that creates the promise | diff --git a/golem-skills/skills/common/golem-add-component/SKILL.md b/golem-skills/skills/common/golem-add-component/SKILL.md index d8d7fb9de6..f409a5dac6 100644 --- a/golem-skills/skills/common/golem-add-component/SKILL.md +++ b/golem-skills/skills/common/golem-add-component/SKILL.md @@ -109,6 +109,8 @@ When the existing application has a single component with `dir: "."` (source fil The CLI shows the planned file moves and asks for confirmation (auto-confirmed with `--yes`). +> **Go:** a single Go component lives in a `module/` directory (`dir: "module"`), not at the app root (its `go.mod` stays sealed away from `golem.yaml`/`golem-temp`). Promotion renames that directory to the component's name (e.g. `module/` → `go-main/`) and creates a sibling directory for the new component. + ## Agent Name Conflicts Default templates all create an agent named `CounterAgent`. When adding a new component using a default template (e.g., `rust`, `ts`, `scala`), the generated agent will conflict with any existing `CounterAgent` in other components, causing deployment failures. 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/golem-skills/skills/common/golem-edit-manifest/SKILL.md b/golem-skills/skills/common/golem-edit-manifest/SKILL.md index 8babe69029..1bb155618f 100644 --- a/golem-skills/skills/common/golem-edit-manifest/SKILL.md +++ b/golem-skills/skills/common/golem-edit-manifest/SKILL.md @@ -66,7 +66,7 @@ Components are keyed by `namespace:name` (e.g., `my-app:billing`). ```yaml components: my-app:billing: - dir: billing # Base directory (relative to golem.yaml). Use "." for single-component apps + dir: billing # Base directory (relative to golem.yaml). Use "." for single-component apps ("module" for Go) templates: # Parent template names (inherit build, env, plugins, files) - rust componentWasm: target/wasm32-wasip1/debug/billing.wasm # Path to built WASM @@ -97,7 +97,7 @@ components: | Field | Type | Description | |-------|------|-------------| -| `dir` | string | Base directory for resolving paths. `"."` for single-component apps | +| `dir` | string | Base directory for resolving paths. `"."` for single-component apps (Go uses `"module"`) | | `templates` | string or string[] | Parent template name(s) to inherit from | | `componentWasm` | string | Path to the built WASM component | | `outputWasm` | string | Path for the final output WASM ready for upload | diff --git a/golem-skills/skills/go/golem-add-agent-go/SKILL.md b/golem-skills/skills/go/golem-add-agent-go/SKILL.md new file mode 100644 index 0000000000..30297ff325 --- /dev/null +++ b/golem-skills/skills/go/golem-add-agent-go/SKILL.md @@ -0,0 +1,160 @@ +--- +name: golem-add-agent-go +description: "Adding a new Go agent to a Golem component. Use when the user asks to create, add, or define a new agent type, split an agent into definition/implementation, or add agent methods in a Go Golem project." +--- + +# Adding a New Agent to a Go Golem Component + +## Overview + +An **agent** is a durable, stateful unit of computation in Golem. In Go each agent is split across two packages: + +- a state-free **definition** (`package `) — the agent's identity, its method descriptors, and the input/output types. Other agents import this package to call it. +- an **implementation** (`package impl`, in a nested `impl/` subpackage) — the private state and the method handlers. Importing this package registers the agent with the SDK. + +This split lets agents call one another without a Go import cycle, and keeps state private to the implementation. + +## Steps + +1. **Create the definition** — add `agents//.go` with `package `. +2. **Declare identity + types** — an `ID` struct (its fields are the constructor parameters), plus any input/output structs. +3. **Define the agent and its methods** — `golem.DefineAgent` + one `golem.DefineMethod` descriptor per method. +4. **Create the implementation** — add `agents//impl/impl.go` with `package impl`: a private `state`, `golem.Implement`, and one `golem.Handle` per method. +5. **Wire it in** — blank-import the impl package in `main.go`. +6. **Build** — run `golem build`. + +## Definition (`agents/counter/counter.go`) + +```go +// Package counter is the DEFINITION of the counter agent. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID holds the constructor parameters, and is the type-level identity used by +// cross-agent calls. Two agents with the same ID are the same agent. +type ID struct{ Name string } + +// AddIn is a method's parameter list: one WIT parameter per exported field. +type AddIn struct{ By int64 } + +// Agent is the state-free definition. Mode defaults to Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Description: "A simple durable counter", +}) + +// Method descriptors are package-level vars: the same value drives the published +// schema, the implementation binding, and calls from other agents. +var ( + Increment = golem.DefineMethod[ID, golem.Unit, int64]("increment", golem.Desc("Increase the count by one")) + Add = golem.DefineMethod[ID, AddIn, int64]("add", golem.Desc("Add to the count")) + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", golem.Desc("Return the current value")) +) +``` + +`golem.Unit` is the empty parameter/result placeholder (a method with no input or no output). + +## Implementation (`agents/counter/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the counter agent. +package impl + +import ( + "myapp/agents/counter" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state is the agent's private, durable state — invisible to callers. +type state struct{ value int64 } + +func (s *state) current() int64 { return s.value } + +// Implement binds the constructor and returns a handle; Handle registers each +// method on it. +var agent = golem.Implement(counter.Agent, func(counter.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.value++ + return ctx.State.value + }) + golem.Handle(agent, counter.Add, func(ctx *golem.Context[state], in counter.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.Handle(agent, counter.Value, golem.Bind0((*state).current)) +} +``` + +The handler receives `*golem.Context[state]`; `ctx.State` is your `*state`. `golem.Bind0` adapts a no-input `(*state)` method into a handler; `golem.Bind` adapts a one-input method. + +## Wiring: `main.go` + +`main.go` (`package main`) blank-imports each agent's **impl** package so its registration runs on import, plus the SDK runtime: + +```go +package main + +import ( + _ "myapp/agents/counter/impl" + + _ "github.com/golemcloud/golem/sdks/go/golem" +) + +func main() {} +``` + +Adding another agent = another `agents//` folder + one more blank import here. + +## Custom Types + +Parameter and result types are Go structs; each exported field becomes one WIT field, named by lower-camel-casing the Go name (`AmountCents` → `amountCents`). + +- Use sized integers (`int64`, `uint64`, …). Bare `int`/`uint` are **rejected** — their width is platform-dependent. +- A `*T` field means `option`. A nil slice/map is an **empty** list/map, never "absent" — use `*[]T` if you must distinguish. +- Variants/enums are declared with `golem.DefineVariant` / `golem.DefineEnum`. + +## Returning Failures + +Handlers return only their output value. Signal failure two ways: + +- **Uncaught errors** — a `panic` (e.g. from `golem.Must(...)` on an unexpected error) is treated as a crash: the invocation is retried per the agent's retry policy, and if retries are exhausted the agent becomes failed. The caller does **not** see it as a normal result. +- **Domain errors** the caller should observe as a value — model them in the method's output type with `golem.Result[Ok, Err]`: + +```go +// definition +var Record = golem.DefineMethod[ID, RecordIn, golem.Result[int64, string]]("record") + +// handler +golem.Handle(agent, Record, func(ctx *golem.Context[state], in RecordIn) golem.Result[int64, string] { + if in.Amount < 0 { + return golem.Err[int64, string]("cannot record a negative amount") + } + ctx.State.total += in.Amount + return golem.Ok[int64, string](ctx.State.total) +}) +``` + +Returning `golem.Err(...)` completes the invocation successfully — the caller receives the error as a value (and can unwrap with `.MustOk()`). Panicking instead triggers a retry and can fail the whole agent. + +## Key Constraints + +- Method parameters/results are passed by value; wrap the parameter list in a struct (one field per WIT parameter). +- `ID` must be a struct; its fields are the agent identity. Agents are created implicitly on first invocation. An `ID` with no fields (`type ID struct{}`) is a **singleton** — exactly one instance of the agent. +- Invocations run **sequentially in a single thread** — no concurrency within one agent, no locks needed. +- Method descriptors must be **package-level vars** in the definition package (the same value is used by the schema, the binding, and callers). +- State lives only in the impl package (unexported) — callers never see it. +- Target is **WASM only**: no raw sockets; outgoing HTTP goes through the SDK's WASI transport (see `golem-make-http-request-go`). + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-call-another-agent-go` | This agent needs to call another agent (RPC) | +| `golem-add-http-endpoint-go` | Expose this agent's methods over HTTP | +| `golem-multi-instance-agent-go` | Address many instances of an agent by ID | +| `golem-custom-snapshot-go` | Customize how the agent's state is snapshotted | diff --git a/golem-skills/skills/go/golem-add-config-go/SKILL.md b/golem-skills/skills/go/golem-add-config-go/SKILL.md new file mode 100644 index 0000000000..73c53dca63 --- /dev/null +++ b/golem-skills/skills/go/golem-add-config-go/SKILL.md @@ -0,0 +1,140 @@ +--- +name: golem-add-config-go +description: "Adding typed configuration to a Go Golem agent with DefineConfiguredAgent and golem.Config. Use when the user asks about agent config, configuration values, config structs, or passing settings to a Go agent." +--- + +# Adding Typed Configuration to a Go Agent + +## Overview + +A Go agent's configuration is a single **config struct** attached to the agent's type. Each exported field becomes a config key; the platform provisions the values (from `golem.yaml`, env, or the CLI) and the agent reads them back at runtime as a typed struct. Config is materialized once per worker and cached, so reads on a hot method are near-free. + +Two things change versus a plain agent: + +- define with `golem.DefineConfiguredAgent[ID, Cfg]` instead of `golem.DefineAgent[ID]`, +- implement with `golem.ImplementConfigured` (its constructor receives an `*golem.InitContext[ID, state, Cfg]`), + +then read the config with `golem.Config(Agent, ctx)` inside a method, or `ctx.Config()` inside the constructor. + +## Steps + +1. **Declare the config struct** — one exported field per config key. +2. **Attach it** with `golem.DefineConfiguredAgent[ID, Cfg]` in the definition. +3. **Implement** with `golem.ImplementConfigured`; read config from the `InitContext` in the constructor. +4. **Read at method time** with `golem.Config(Agent, ctx)`. +5. **Provide values** under `agents..config` in `golem.yaml`. + +## Definition (`agents/shop/shop.go`) + +```go +// Package shop is the DEFINITION of the shop agent. +package shop + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +// Config is the agent's whole config surface. Each exported field is a config +// key; a nested struct flattens into multi-segment paths; a pointer field is +// optional; list/map fields decode as their WIT shapes. +type Config struct { + Greeting string + Tax TaxConfig // nested → paths tax.ratePct + Timezone *string // optional (read back as nil when unset) + Features []string // list + Limits map[string]int64 // map +} + +type TaxConfig struct{ RatePct int64 } + +var Agent = golem.DefineConfiguredAgent[ID, Config](golem.Spec{ + Name: "ShopAgent", + Description: "A shop whose behaviour is driven by config", +}) + +var ( + Greet = golem.DefineMethod[ID, golem.Unit, string]("greet", golem.Desc("Greeting, from config")) + Settings = golem.DefineMethod[ID, golem.Unit, []string]("settings", golem.Desc("Return the configured features")) +) +``` + +Field-name conventions match plain agent types: use sized integers (`int64`, not bare `int`), a `*T` field is `option`, and nested structs recurse. Field names are lower-camel-cased for the wire (`RatePct` → `ratePct`). + +## Implementation (`agents/shop/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the shop agent. +package impl + +import ( + "myapp/agents/shop" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ greeting string } + +// ImplementConfigured binds the constructor; its InitContext exposes Config(). +var agent = golem.ImplementConfigured(shop.Agent, + func(ctx *golem.InitContext[shop.ID, state, shop.Config]) *state { + // Constructor-time config read: seed state once from config. + return &state{greeting: ctx.Config().Greeting} + }) + +func init() { + golem.Handle(agent, shop.Greet, func(ctx *golem.Context[state], _ golem.Unit) string { + return ctx.State.greeting + }) + + golem.Handle(agent, shop.Settings, func(ctx *golem.Context[state], _ golem.Unit) []string { + cfg := golem.Config(shop.Agent, ctx) // method-time config read + return cfg.Features + }) +} +``` + +`golem.Config(shop.Agent, ctx)` returns the whole `shop.Config` value; `ctx` is the running method's `*golem.Context[state]` (requiring it means config is only readable from inside a running method). The constructor reads the same config via `ctx.Config()` on its `InitContext`. + +## Providing Values in `golem.yaml` + +Set defaults under `agents..config`. Keys are **camelCase** — they match the lower-camel-cased Go field names; nested structs are nested maps, and a `map[string]V` is a list of `[key, value]` pairs: + +```yaml +agents: + ShopAgent: + config: + greeting: "Welcome to ACME" + tax: + ratePct: 20 + features: ["fast-checkout", "gift-wrap"] + limits: [["maxItems", 100]] + # timezone is omitted → the optional *string field reads back as nil +``` + +## Overriding Config Over RPC + +When one agent calls another, the caller can override the callee's **local** (non-secret) config at client creation with `golem.WithConfig`: + +```go +client := shop.Agent.Get( + shop.ID{Name: "acme"}, + golem.WithConfig(shop.Config{Greeting: "Hi from the caller"}), +) +``` + +Only declared local keys can be overridden; secret fields are always platform-provisioned and are skipped. + +## Key Constraints + +- Config is **agent-attached and instance-bound** — read only from within that agent's own constructor or methods, never from free-floating code. +- Reading an **undeclared** key, or an unset **required** key, traps. Declare a field as a pointer (`*T`) to read an absent value back as `nil` instead of trapping. +- Config is materialized **once per worker** and cached; local fields are read on first access and reused for the worker's life. (Secret fields stay live — see `golem-add-secret-go`.) +- Use `golem.DefineAgent[ID]` (no config) for agents that need none; `golem.NoConfig` is the empty config type and never needs naming. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Define the base agent this config attaches to | +| `golem-add-secret-go` | Add `golem.Secret[T]` fields for sensitive values | +| `golem-call-another-agent-go` | Override a callee's config with `golem.WithConfig` over RPC | diff --git a/golem-skills/skills/go/golem-add-cors-go/SKILL.md b/golem-skills/skills/go/golem-add-cors-go/SKILL.md new file mode 100644 index 0000000000..411496ec01 --- /dev/null +++ b/golem-skills/skills/go/golem-add-cors-go/SKILL.md @@ -0,0 +1,86 @@ +--- +name: golem-add-cors-go +description: "Configuring CORS on a Go agent's HTTP endpoints. Use when the user asks to enable CORS, allow cross-origin requests, or configure allowed origins for HTTP endpoints in a Go Golem project." +--- + +# Configuring CORS on Go HTTP Endpoints + +## Overview + +CORS allowed-origin patterns are declared on the agent **definition**: mount-wide with `Mount.CORS`, or per route with `golem.EndpointCORS`. Origins declared at both levels are **unioned** for that route. CORS is metadata only — declaring it advertises the origins the platform will allow; the gateway handles preflight automatically. + +## Steps + +1. **Set mount-level origins** with `Mount.CORS` to cover every endpoint. +2. **Add per-endpoint origins** with `golem.EndpointCORS(patterns...)`; they union with the mount list. +3. **Use `"*"`** to allow all origins. + +## Mount-level CORS + +`Mount.CORS` is a `[]string` of allowed-origin patterns applied to **all** endpoints: + +```go +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "MyAgent", + HTTP: &golem.Mount{ + Path: "/api/{name}", + CORS: []string{"https://app.example.com"}, // all endpoints + }, +}) + +// GET /api/{name}/data — allows https://app.example.com +var GetData = golem.DefineMethod[ID, golem.Unit, Data]("getData", + golem.HTTP(golem.GET("/data"))) +``` + +## Endpoint-level CORS + +`golem.EndpointCORS(patterns...)` adds origins for one route. They are **unioned** with the mount-level list, not replaced: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "MyAgent", + HTTP: &golem.Mount{Path: "/api/{name}", CORS: []string{"https://app.example.com"}}, +}) + +var ( + // Allows BOTH https://app.example.com AND * (all origins) + GetData = golem.DefineMethod[ID, golem.Unit, Data]("getData", + golem.HTTP(golem.GET("/data", golem.EndpointCORS("*")))) + + // Inherits mount-level only: https://app.example.com + GetOther = golem.DefineMethod[ID, golem.Unit, Data]("getOther", + golem.HTTP(golem.GET("/other"))) +) +``` + +## Wildcard + +Use `"*"` to allow all origins: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "PublicAgent", + HTTP: &golem.Mount{Path: "/public/{name}", CORS: []string{"*"}}, +}) +``` + +## CORS preflight + +The platform handles `OPTIONS` preflight requests automatically for endpoints that have CORS configured — you do not declare an `OPTIONS` route yourself. The preflight response carries `Access-Control-Allow-Origin`, `Access-Control-Allow-Methods`, and `Access-Control-Allow-Headers`. + +## Key Constraints + +- `Mount.CORS` and `golem.EndpointCORS(patterns...)` both take origin patterns; the effective set for a route is the **union** of the two. +- An empty `CORS` means no cross-origin access is allowed for that scope. +- CORS declared in code still requires the agent to be served behind an `httpApi` deployment (see `golem-add-http-endpoint-go`). + +### Related Skills + +| Skill | When to Load | +|---|---| +| `golem-add-http-endpoint-go` | Set up the mount and endpoints before adding CORS | +| `golem-add-http-auth-go` | Require authentication on the endpoints | +| `golem-http-params-go` | Bind request path/query/header/body to method inputs | diff --git a/golem-skills/skills/go/golem-add-go-module/SKILL.md b/golem-skills/skills/go/golem-add-go-module/SKILL.md new file mode 100644 index 0000000000..021b26b5f5 --- /dev/null +++ b/golem-skills/skills/go/golem-add-go-module/SKILL.md @@ -0,0 +1,53 @@ +--- +name: golem-add-go-module +description: "Add a Go module dependency to a Go Golem project. Use when the user asks to add a library, package, module, or dependency in Go." +--- + +# Add a Go Module Dependency + +## Important constraints + +- The component compiles to a WebAssembly component (WASI) via `componentize-go` — only code that works on that target will build. +- Modules that use OS threads, raw sockets (`net.Dial`), most database drivers, `cgo`, or platform-specific syscalls **will not work**. +- Pure-Go modules, and modules that do I/O through the standard library the SDK adapts (e.g. HTTP via `net/http`), generally work. +- If unsure whether a module builds for WASM, add it and run `golem build` to find out. + +## Steps + +1. **Add the dependency** in the component's module directory (where its `go.mod` lives): + + ```shell + go get github.com/example/mod@latest + ``` + + Then import and use it in your code. `go get` records it in `go.mod`. + +2. **Build to verify** + + ```shell + golem build --yes + ``` + + `golem build` runs `go mod tidy` for you before compiling. Do NOT rely on a bare `go build` for the component — it can't link the WASI component; always use `golem build`. + +3. **If the build fails** + + - Look for `wasip1`/`wasm`-unsupported errors, references to `net`, `syscall`, or C dependencies — those modules are incompatible with the WASM target. + - Check whether the module offers a pure-Go or `wasm` build mode/build tag. + - Look for an alternative module that supports WASM. + +## Already available (do NOT re-add) + +- `github.com/golemcloud/golem/sdks/go/golem` — the Golem Go SDK (agents, durability, RPC, retry, config/secrets, keyvalue/blobstore/rdbms/websocket, logging). Its subpackages (`.../golem/retry`, `.../golem/keyvalue`, etc.) are part of the same module. +- `github.com/bytecodealliance/componentize-go` — pinned as a **`tool`** dependency in `go.mod` so `go tool componentize-go` runs the pinned version. Leave the `tool` directive in place; don't remove it. + +## HTTP and networking + +Use the standard `net/http` package — the SDK routes it through the durable WASI HTTP transport (see `golem-make-http-request-go`). Raw sockets (`net.Dial`, `crypto/tls` over a custom conn) are **not** available on the WASM target. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-make-http-request-go` | Call an external service over HTTP | +| `golem-add-agent-go` | Use a new dependency inside an agent | diff --git a/golem-skills/skills/go/golem-add-http-auth-go/SKILL.md b/golem-skills/skills/go/golem-add-http-auth-go/SKILL.md new file mode 100644 index 0000000000..e86ae90783 --- /dev/null +++ b/golem-skills/skills/go/golem-add-http-auth-go/SKILL.md @@ -0,0 +1,103 @@ +--- +name: golem-add-http-auth-go +description: "Requiring authentication on a Go agent's HTTP endpoints. Use when the user asks to add auth, require authentication, or protect HTTP endpoints in a Go Golem project." +--- + +# Requiring Authentication on Go HTTP Endpoints + +## Overview + +Golem authenticates HTTP endpoints via OIDC providers. Auth is declared on the agent **definition** — mount-wide with `Mount.Auth`, or per route with `golem.EndpointAuth` — and then wired to a security scheme in the manifest's (`golem.yaml`) `httpApi` deployment. Declaring auth in code without a matching deployment configuration only advertises the requirement; serving it needs the deployment. + +## Steps + +1. **Require auth** at the mount (`Mount{Auth: true}`) or per endpoint (`golem.EndpointAuth(true)`). +2. **Override where needed** — a per-endpoint `golem.EndpointAuth(...)` beats the mount default. +3. **Configure a security scheme** in `golem.yaml` under the `httpApi` deployment. + +## Auth on all endpoints (mount level) + +Set `Auth: true` on the `Mount` to require authentication for every endpoint of the agent: + +```go +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "SecureAgent", + HTTP: &golem.Mount{Path: "/secure/{name}", Auth: true}, // all endpoints require auth +}) +``` + +## Auth on individual endpoints + +With no mount-level default, require auth on a specific route with `golem.EndpointAuth(true)`: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ApiAgent", + HTTP: &golem.Mount{Path: "/api/{name}"}, +}) + +var ( + // GET /api/{name}/public — open + Public = golem.DefineMethod[ID, golem.Unit, string]("public", + golem.HTTP(golem.GET("/public"))) + + // GET /api/{name}/private — requires auth + Private = golem.DefineMethod[ID, golem.Unit, string]("private", + golem.HTTP(golem.GET("/private", golem.EndpointAuth(true)))) +) +``` + +## Overriding the mount default + +A per-endpoint `golem.EndpointAuth` overrides the mount's `Auth`. Use `false` to open a single route on an otherwise-protected agent: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "MostlySecureAgent", + HTTP: &golem.Mount{Path: "/api/{name}", Auth: true}, // default: auth required +}) + +var ( + // GET /api/{name}/health — override to open + Health = golem.DefineMethod[ID, golem.Unit, string]("health", + golem.HTTP(golem.GET("/health", golem.EndpointAuth(false)))) + + // GET /api/{name}/data — inherits the mount default (auth required) + GetData = golem.DefineMethod[ID, golem.Unit, Data]("getData", + golem.HTTP(golem.GET("/data"))) +) +``` + +## Deployment configuration + +After declaring auth in code, configure a security scheme in `golem.yaml` under the `httpApi` deployment (this is where `subdomain` versus `domain` is chosen). Quick reference: + +```yaml +httpApi: + deployments: + local: + - subdomain: my-app # resolves to my-app.localhost:9006 by default + agents: + SecureAgent: + securityScheme: my-oidc # production OIDC + # or for development: + # SecureAgent: + # testSessionHeaderName: X-Test-Auth +``` + +## Key Constraints + +- `Mount.Auth` is a plain `bool`; `golem.EndpointAuth(required bool)` takes an explicit value (`true` to require, `false` to open). +- Setting `golem.EndpointAuth` **more than once** on one endpoint is a definition error, not a silent overwrite — set it exactly once per route. +- An endpoint with no `golem.EndpointAuth` inherits the mount's `Auth`. +- Declaring auth requires an `httpApi` deployment with a security scheme to actually enforce it — mounting alone only advertises the requirement. + +### Related Skills + +| Skill | When to Load | +|---|---| +| `golem-add-http-endpoint-go` | Set up the mount and endpoints before adding auth | +| `golem-add-cors-go` | Allow cross-origin requests to the endpoints | +| `golem-http-params-go` | Bind request path/query/header/body to method inputs | diff --git a/golem-skills/skills/go/golem-add-http-endpoint-go/SKILL.md b/golem-skills/skills/go/golem-add-http-endpoint-go/SKILL.md new file mode 100644 index 0000000000..ab759f922e --- /dev/null +++ b/golem-skills/skills/go/golem-add-http-endpoint-go/SKILL.md @@ -0,0 +1,90 @@ +--- +name: golem-add-http-endpoint-go +description: "Exposing a Go agent's methods over HTTP. Use when the user wants to add an HTTP endpoint/route to an agent, mount an agent under a URL path, make agent methods callable over HTTP, or map path/query/header parameters in a Go Golem project." +--- + +# Exposing a Go Agent over HTTP + +## Overview + +HTTP mounting is **metadata only**: you declare, on the agent's definition, a URL prefix for the agent and a route for each method. The platform routes matching requests to the right instance and method — there is no incoming-request handler to write in the guest. + +Two pieces, both on the **definition**: + +1. `Spec.HTTP = &golem.Mount{Path: "…"}` — the agent-level prefix. Its `{var}` segments bind the agent's constructor (`ID`) fields, so a request URL selects the instance. **Every `ID` field must appear as a `{var}`.** +2. `golem.HTTP(golem.GET("/suffix"), …)` as a method option — one or more routes per method, with request data bound to the method's input fields. + +## Steps + +1. **Add a mount** to the agent's `Spec`: `HTTP: &golem.Mount{Path: "/counters/{name}"}`. +2. **Add routes** to methods with the `golem.HTTP(...)` option and a verb constructor. +3. **Bind request data** to input fields (path `{var}`, `golem.Query`, `golem.Header`, or the JSON body). +4. **Build**, then **deploy behind an HTTP API** so the routes are served. + +## Example (definition) + +```go +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } // bound by {name} in the mount path + +type AddIn struct{ By int64 } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Description: "A counter exposed over HTTP", + // {name} binds ID.Name; CORS/Auth optional. + HTTP: &golem.Mount{Path: "/counters/{name}", CORS: []string{"*"}}, +}) + +var ( + // GET /counters/{name}/value — options compose: Desc + HTTP in one call. + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", + golem.Desc("Read the current value"), golem.HTTP(golem.GET("/value"))) + + // POST /counters/{name}/add — AddIn arrives as the JSON body + Add = golem.DefineMethod[ID, AddIn, int64]("add", + golem.Desc("Add to the count"), golem.HTTP(golem.POST("/add"))) +) +``` + +The handlers are ordinary handlers (see `golem-add-agent-go`) — nothing HTTP-specific in the impl. + +## Binding request data to input fields + +- **Path variables** — `{sku}` in a route suffix binds the input field `Sku`: `golem.GET("/items/{sku}")`. +- **Query parameters** — `golem.Query("detailed", "detailed")` binds `?detailed=` to the `Detailed` field: + ```go + Lookup = golem.DefineMethod[ID, LookupIn, ItemInfo]("lookup", + golem.HTTP(golem.GET("/items/{sku}", golem.Query("detailed", "detailed")))) + ``` +- **Headers** — `golem.Header("X-Tenant", "tenant")` binds the header to the `Tenant` field. +- **Body** — for body-carrying verbs (`POST`/`PUT`), input fields not bound to path/query/header come from the JSON request body. + +## Auth & CORS + +- `Mount{Auth: true}` requires auth on every endpoint; `golem.EndpointAuth(true|false)` overrides it per route: + ```go + golem.HTTP(golem.GET("/items/{sku}", golem.EndpointAuth(true))) + ``` +- `Mount{CORS: []string{"*"}}` sets allowed origins for the agent; `golem.EndpointCORS(patterns...)` overrides per route. + +## Verbs + +`golem.GET`, `golem.POST`, `golem.PUT`, `golem.DELETE`, and `golem.Custom("VERB", "/path")`. `GET`/`HEAD` are bodyless — bind their inputs from path/query/header. + +## Key Constraints + +- Every `ID` field must appear as a `{var}` in `Mount.Path` (else the platform can't identify the instance); path vars may also be literals or the trailing catch-all `{*rest}`. +- A method with an HTTP endpoint but no agent-level `Spec.HTTP` mount is a definition error — set the mount. +- Serving the routes requires an HTTP API deployment (see the manifest `httpApi` configuration); mounting alone only advertises the routes. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Define the agent whose methods you're exposing | +| `golem-make-http-request-go` | Make an *outgoing* HTTP request from agent code | +| `golem-multi-instance-agent-go` | The `{var}` path segments select an instance by ID | diff --git a/golem-skills/skills/go/golem-add-mysql-go/SKILL.md b/golem-skills/skills/go/golem-add-mysql-go/SKILL.md new file mode 100644 index 0000000000..b90943ea41 --- /dev/null +++ b/golem-skills/skills/go/golem-add-mysql-go/SKILL.md @@ -0,0 +1,175 @@ +--- +name: golem-add-mysql-go +description: "Using MySQL from a Go Golem agent via the golem/rdbms/mysql wrapper. Use when the user asks to connect to MySQL, run SQL, scan rows, or execute a MySQL transaction in a Go Golem project." +--- + +# Using MySQL from a Go Agent + +## Overview + +The Go SDK ships a durable MySQL client at `github.com/golemcloud/golem/sdks/go/golem/rdbms/mysql`. It mirrors the `postgres` wrapper: open a connection with a URL, then run parametrised statements in a `database/sql`-flavoured style. Every query, execute, and commit is journaled and replayed, so the connection is durable across restarts. + +There is **no** native driver and **no** raw socket — all traffic goes through the `golem:rdbms` host, so nothing needs wiring beyond importing the subpackage. Unlike Postgres, MySQL has no recursive value families, so every value maps directly to a Go value. + +## Steps + +1. **Import** `.../golem/rdbms/mysql` in your agent's `impl` package. +2. **Open** a connection with `mysql.Open(addr)` and `defer db.Close()`. +3. **Exec / Query** with `?` placeholders; pass plain Go values or typed constructors. +4. **Scan** rows with `row.Scan(&dst…)` or the typed getters. +5. **Transactions** via `db.Transaction(func(tx *mysql.Tx) error { … })`. + +Prefer a config value or env var for the connection string over hardcoding it (see `golem-add-config-go`). + +## Definition (`agents/notes/notes.go`) + +```go +// Package notes is the DEFINITION of the notes agent. +package notes + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type AddIn struct { + Addr string + Body string +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "NotesAgent", Description: "Durable MySQL-backed notes", +}) + +var ( + Add = golem.DefineMethod[ID, AddIn, int64]("add", golem.Desc("Insert a note, return the new count")) + List = golem.DefineMethod[ID, golem.Unit, []string]("list", golem.Desc("Return all note bodies")) +) +``` + +## Implementation (`agents/notes/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the notes agent. +package impl + +import ( + "myapp/agents/notes" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/rdbms/mysql" +) + +type state struct{} + +var agent = golem.Implement(notes.Agent, func(notes.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, notes.Add, func(_ *golem.Context[state], in notes.AddIn) int64 { + db := golem.Must(mysql.Open(in.Addr)) // "mysql://user:pass@host:3306/app" + defer db.Close() + + golem.Must(db.Exec(`CREATE TABLE IF NOT EXISTS notes ( + id bigint AUTO_INCREMENT PRIMARY KEY, body varchar(255) NOT NULL)`)) + + // Placeholders are ?; a bare Go string maps to varchar. + golem.Must(db.Exec(`INSERT INTO notes (body) VALUES (?)`, in.Body)) + + count := golem.Must(db.Query(`SELECT count(*) FROM notes`)) + n, _ := count.Rows()[0].Int64(0) // read column 0 as int64 + return n + }) + + golem.Handle(agent, notes.List, func(_ *golem.Context[state], _ golem.Unit) []string { + db := golem.Must(mysql.Open("mysql://user:pass@localhost:3306/app")) + defer db.Close() + + rs := golem.Must(db.Query(`SELECT body FROM notes ORDER BY id`)) + var out []string + for _, r := range rs.Rows() { + var body string + golem.Must0(r.Scan(&body)) // Scan fills dsts positionally + out = append(out, body) + } + return out + }) +} +``` + +`golem.Must` unwraps `(value, error)` and panics on error (aborting the invocation, which then retries per the agent's policy); `golem.Must0` does the same for an error-only return like `Scan`. + +## Parameters and Row Getters + +Parameters are ordinary Go values — `nil`, `bool`, the signed **and unsigned** int widths, `float32`/`float64`, `string`, `[]byte`, and `time.Time` map to their natural MySQL types: + +```go +golem.Must(db.Exec( + `INSERT INTO events (id, name, qty, at) VALUES (?, ?, ?, ?)`, + int64(1), "alice", uint32(3), time.Now(), +)) +``` + +When the exact column type matters (decimal, a specific integer width, json, enum), build the parameter with a constructor from the package — each returns a `mysql.DbValue`: + +```go +golem.Must(db.Exec( + `INSERT INTO items (id, price, meta) VALUES (?, ?, ?)`, + mysql.Bigint(1), + mysql.Decimal("12.3400"), // exact decimal from string, no float rounding + mysql.JSON(`{"featured":true}`), // json from serialized text +)) +``` + +Read columns back positionally with the typed getters on `mysql.Row` — `Int64`, `Float64`, `String`, `Bool`, `Bytes`, `Time`, the generic `Get`, or `Scan`. Each returns `(value, error)`: + +```go +row := golem.Must(db.Query(`SELECT id, name, at FROM events WHERE id = ?`, int64(1))).Rows()[0] +id := golem.Must(row.Int64(0)) +name := golem.Must(row.String(1)) +at := golem.Must(row.Time(2)) +``` + +`rs.Columns()` returns the `[]mysql.Column` metadata (`Ordinal`, `Name`, `DbTypeName`). + +## Transactions + +`db.Transaction` runs a closure inside a transaction, committing if it returns `nil` and rolling back (returning the error) otherwise: + +```go +golem.Must0(db.Transaction(func(tx *mysql.Tx) error { + if _, err := tx.Exec(`UPDATE notes SET body = ? WHERE id = ?`, "updated", int64(1)); err != nil { + return err + } + return nil // returning an error here rolls back instead +})) +``` + +For manual control use `db.Begin()` then `tx.Exec` / `tx.Query` and `tx.Commit()` or `tx.Rollback()`. + +## Returning Host Errors to the Caller + +`golem.Must*` treats a host error as a crash (retry). To let the caller *observe* a failure as a value instead, keep the fallible call's `error` and model the method output as `golem.Result[Ok, Err]`: + +```go +db, err := mysql.Open(in.Addr) +if err != nil { + return golem.Err[int64, string](err.Error()) +} +``` + +## Key Constraints + +- Target is **WASM only**: no native `go-sql-driver/mysql`, no raw sockets. All SQL goes through the `golem:rdbms` host — just import `.../rdbms/mysql`. +- The connection is **durable**: every query/execute/commit is journaled and replayed. Because these are remote side effects, using the client inside a **read-only** method traps (see `golem-mark-read-only-go`). +- Placeholders are `?` (MySQL style). Postgres uses `$1, $2, …` — see `golem-add-postgres-go`. +- Bare `int` maps to `bigint`; use `mysql.Int(...)` for a 32-bit integer column and the `*Unsigned` constructors (or plain `uint*` values) for unsigned columns. All getters and fallible calls return `(value, error)` — pair them with `golem.Must` / `golem.Must0`. +- An unsupported plain parameter type errors at encode time with a message telling you to wrap it in a `mysql.*` constructor. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Create the agent that owns this MySQL client | +| `golem-add-postgres-go` | Use PostgreSQL instead of (or alongside) MySQL | +| `golem-add-config-go` | Read the connection string from typed config | +| `golem-add-transactions-go` | Coordinate a saga across agents (distinct from a single DB transaction) | +| `golem-mark-read-only-go` | Understand why DB calls trap in read-only methods | diff --git a/golem-skills/skills/go/golem-add-postgres-go/SKILL.md b/golem-skills/skills/go/golem-add-postgres-go/SKILL.md new file mode 100644 index 0000000000..a6b5d6098c --- /dev/null +++ b/golem-skills/skills/go/golem-add-postgres-go/SKILL.md @@ -0,0 +1,176 @@ +--- +name: golem-add-postgres-go +description: "Using PostgreSQL from a Go Golem agent via the golem/rdbms/postgres wrapper. Use when the user asks to connect to PostgreSQL, run SQL, scan rows, or execute a Postgres transaction in a Go Golem project." +--- + +# Using PostgreSQL from a Go Agent + +## Overview + +The Go SDK ships a durable Postgres client at `github.com/golemcloud/golem/sdks/go/golem/rdbms/postgres`. It wraps Golem's `golem:rdbms` host in a `database/sql`-flavoured API: open a connection with a URL, then run parametrised statements and scan the rows back positionally. Every query, execute, and commit is journaled and replayed, so the connection is durable across restarts. + +There is **no** native driver and **no** raw socket — all traffic goes through the `golem:rdbms` host, so nothing needs wiring beyond importing the subpackage. + +## Steps + +1. **Import** `.../golem/rdbms/postgres` in your agent's `impl` package. +2. **Open** a connection with `postgres.Open(addr)` and `defer db.Close()`. +3. **Exec / Query** with `$1, $2, …` placeholders; pass plain Go values or typed constructors. +4. **Scan** rows with `row.Scan(&dst…)` or the typed getters. +5. **Transactions** via `db.Transaction(func(tx *postgres.Tx) error { … })`. + +Prefer a config value or env var for the connection string over hardcoding it (see `golem-add-config-go`). + +## Definition (`agents/notes/notes.go`) + +```go +// Package notes is the DEFINITION of the notes agent. +package notes + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type AddIn struct { + Addr string + Body string +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "NotesAgent", Description: "Durable Postgres-backed notes", +}) + +var ( + Add = golem.DefineMethod[ID, AddIn, int64]("add", golem.Desc("Insert a note, return the new count")) + List = golem.DefineMethod[ID, golem.Unit, []string]("list", golem.Desc("Return all note bodies")) +) +``` + +## Implementation (`agents/notes/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the notes agent. +package impl + +import ( + "myapp/agents/notes" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/rdbms/postgres" +) + +type state struct{} + +var agent = golem.Implement(notes.Agent, func(notes.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, notes.Add, func(_ *golem.Context[state], in notes.AddIn) int64 { + db := golem.Must(postgres.Open(in.Addr)) // "postgres://user:pass@host:5432/app" + defer db.Close() + + golem.Must(db.Exec(`CREATE TABLE IF NOT EXISTS notes ( + id bigserial PRIMARY KEY, body text NOT NULL)`)) + + // Placeholders are $1, $2, …; a bare Go string maps to text. + golem.Must(db.Exec(`INSERT INTO notes (body) VALUES ($1)`, in.Body)) + + count := golem.Must(db.Query(`SELECT count(*) FROM notes`)) + n, _ := count.Rows()[0].Int64(0) // read column 0 as int64 + return n + }) + + golem.Handle(agent, notes.List, func(_ *golem.Context[state], _ golem.Unit) []string { + db := golem.Must(postgres.Open("postgres://user:pass@localhost:5432/app")) + defer db.Close() + + rs := golem.Must(db.Query(`SELECT body FROM notes ORDER BY id`)) + var out []string + for _, r := range rs.Rows() { + var body string + golem.Must0(r.Scan(&body)) // Scan fills dsts positionally + out = append(out, body) + } + return out + }) +} +``` + +`golem.Must` unwraps `(value, error)` and panics on error (aborting the invocation, which then retries per the agent's policy); `golem.Must0` does the same for an error-only return like `Scan`. + +## Parameters and Row Getters + +Parameters are ordinary Go values — `nil`, `bool`, the sized int/float widths, `string`, `[]byte`, `uuid.UUID`, and `time.Time` map to their natural Postgres types: + +```go +golem.Must(db.Exec( + `INSERT INTO events (id, name, at, ok) VALUES ($1, $2, $3, $4)`, + int64(1), "alice", time.Now(), true, +)) +``` + +When the exact column type matters (numeric, jsonb, a specific integer width, arrays, enums, composites), build the parameter with a constructor from the package — each returns a `postgres.DbValue` you pass like any other argument: + +```go +golem.Must(db.Exec( + `INSERT INTO items (id, price, tags, meta) VALUES ($1, $2, $3, $4)`, + postgres.Int8(1), + postgres.Numeric("12.34"), // exact decimal from string, no float rounding + postgres.Array(int32(10), int32(20)), // int[] array + postgres.JSONB(`{"featured":true}`), // jsonb from serialized text +)) +``` + +Read columns back positionally with the typed getters on `postgres.Row` — `Int64`, `Float64`, `String`, `Bool`, `Bytes`, `UUID`, `Time`, the recursive `Array` / `Enum` / `Composite` / `Int4Range`, the generic `Get`, or `Scan`. Each returns `(value, error)`: + +```go +row := golem.Must(db.Query(`SELECT id, name, at FROM events WHERE id = $1`, int64(1))).Rows()[0] +id := golem.Must(row.Int64(0)) +name := golem.Must(row.String(1)) +at := golem.Must(row.Time(2)) +``` + +`rs.Columns()` returns the `[]postgres.Column` metadata (`Ordinal`, `Name`, `DbTypeName`). + +## Transactions + +`db.Transaction` runs a closure inside a transaction, committing if it returns `nil` and rolling back (returning the error) otherwise: + +```go +golem.Must0(db.Transaction(func(tx *postgres.Tx) error { + if _, err := tx.Exec(`UPDATE notes SET body = $1 WHERE id = $2`, "updated", int64(1)); err != nil { + return err + } + return nil // returning an error here rolls back instead +})) +``` + +For manual control use `db.Begin()` then `tx.Exec` / `tx.Query` and `tx.Commit()` or `tx.Rollback()`. + +## Returning Host Errors to the Caller + +`golem.Must*` treats a host error as a crash (retry). To let the caller *observe* a failure as a value instead, keep the fallible call's `error` and model the method output as `golem.Result[Ok, Err]`: + +```go +db, err := postgres.Open(in.Addr) +if err != nil { + return golem.Err[int64, string](err.Error()) +} +``` + +## Key Constraints + +- Target is **WASM only**: no native `pgx`/`lib/pq` driver, no raw sockets. All SQL goes through the `golem:rdbms` host — just import `.../rdbms/postgres`. +- The connection is **durable**: every query/execute/commit is journaled and replayed. Because these are remote side effects, using the client inside a **read-only** method traps (see `golem-mark-read-only-go`). +- Placeholders are `$1, $2, …` (Postgres style). MySQL uses `?` — see `golem-add-mysql-go`. +- Bare `int` maps to `int8` (bigint); use `postgres.Int4(...)` when you need a 32-bit integer column. All getters and fallible calls return `(value, error)` — pair them with `golem.Must` / `golem.Must0`. +- An unsupported plain parameter type errors at encode time with a message telling you to wrap it in a `postgres.*` constructor. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Create the agent that owns this Postgres client | +| `golem-add-mysql-go` | Use MySQL instead of (or alongside) Postgres | +| `golem-add-config-go` | Read the connection string from typed config | +| `golem-add-transactions-go` | Coordinate a saga across agents (distinct from a single DB transaction) | +| `golem-mark-read-only-go` | Understand why DB calls trap in read-only methods | diff --git a/golem-skills/skills/go/golem-add-secret-go/SKILL.md b/golem-skills/skills/go/golem-add-secret-go/SKILL.md new file mode 100644 index 0000000000..6c5f0e6848 --- /dev/null +++ b/golem-skills/skills/go/golem-add-secret-go/SKILL.md @@ -0,0 +1,127 @@ +--- +name: golem-add-secret-go +description: "Adding typed secrets to a Go Golem agent with golem.Secret[T]. Use when the user needs API keys, passwords, or tokens that must not be checked into source control in a Go Golem project." +--- + +# Adding Secrets to a Go Agent + +## Overview + +Secrets are sensitive configuration values (API keys, passwords, tokens) read at runtime through `golem.Secret[T]`. A secret uses the **same config mechanism as regular typed config** — it is just a field whose type is `golem.Secret[T]` inside the agent's config struct (see `golem-add-config-go`). The config value carries an opaque secret handle; the plaintext is revealed only when your code calls `.Get()`. + +Secrets are **not** stored in `golem.yaml` (which is source-controlled) except through `secretDefaults` for local development. In real environments they are managed per-environment via the CLI. + +## Steps + +1. **Add a `golem.Secret[T]` field** to the agent's config struct. +2. **Define / implement** the agent as a configured agent (`DefineConfiguredAgent` + `ImplementConfigured`). +3. **Reveal** the value at runtime with `.Get()`. +4. **Provide values** via `secretDefaults` (local) or the CLI (per environment). + +## Declaring a Secret Field + +A secret is any field of type `golem.Secret[T]`, at any depth of the config struct: + +```go +// Package client is the DEFINITION of an API-client agent. +package client + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type Config struct { + Endpoint string + APIKey golem.Secret[string] // a secret leaf + DB DBConfig +} + +type DBConfig struct { + Host string + Password golem.Secret[string] // secret at path db.password +} + +var Agent = golem.DefineConfiguredAgent[ID, Config](golem.Spec{ + Name: "ClientAgent", + Description: "Calls an external API using a secret key", +}) + +var Connect = golem.DefineMethod[ID, golem.Unit, string]("connect", + golem.Desc("Describe the connection using secret values")) +``` + +## Reading a Secret at Runtime + +Read the config, then call `.Get()` on the secret field to reveal the current plaintext. Because `.Get()` re-reads the host on every call, a *rotated* secret is observed rather than a stale snapshot: + +```go +// Package impl is the IMPLEMENTATION of the API-client agent. +package impl + +import ( + "fmt" + + "myapp/agents/client" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.ImplementConfigured(client.Agent, + func(_ *golem.InitContext[client.ID, state, client.Config]) *state { return &state{} }) + +func init() { + golem.Handle(agent, client.Connect, func(ctx *golem.Context[state], _ golem.Unit) string { + cfg := golem.Config(client.Agent, ctx) + + apiKey := cfg.APIKey.Get() // reveals the current plaintext + dbPass := cfg.DB.Password.Get() // secret at any depth + + return fmt.Sprintf("connecting to %s (key len=%d, db host=%s, pw len=%d)", + cfg.Endpoint, len(apiKey), cfg.DB.Host, len(dbPass)) + }) +} +``` + +A `golem.Secret[T]` cannot be constructed from a plaintext and cannot be a method parameter or return value — it is config-only, always obtained from the agent's config. Its `String()`/`GoString()` render as `golem.Secret(redacted)`, so it stays out of logs formatted with `%v`/`%s`. + +## Secret Defaults in `golem.yaml` (local only) + +For local development, set defaults under `secretDefaults.`. Keys are **camelCase** and follow the same path flattening as config; nested structs are nested maps. These are **not** used in production: + +```yaml +secretDefaults: + local: + apiKey: "dev-key-123" + db: + password: "dev-password" +``` + +## Managing Secrets via CLI (per environment) + +Outside local defaults, secrets are environment-scoped — each deployment environment has its own values, set through the platform CLI (paths use the same camelCase as the config keys): + +```shell +golem secret create apiKey --secret-type String --secret-value "sk-abc123" +golem secret create db.password --secret-type String --secret-value "s3cret" +golem secret list +golem secret update-value apiKey --secret-value "new-value" +golem secret delete apiKey +``` + +## Key Constraints + +- A secret is a **config field** of type `golem.Secret[T]` — the agent must be a configured agent (`DefineConfiguredAgent` / `ImplementConfigured`); see `golem-add-config-go`. +- Only **`.Get()`** reveals the plaintext, and it re-reads the host each call, so a rotated value is observed without restarting the agent. Each reveal pins the resolved revision for deterministic retry/replay. +- Secret values are **never** written to `golem.yaml` except via `secretDefaults` (local dev). Production values come from the CLI, per environment. +- A missing required secret fails agent creation/deployment. Read a secret from within an invocation only — `.Get()` calls the host, and a read failure panics (surfaces as an agent error). +- Over RPC, secret fields are always platform-provisioned; `golem.WithConfig` overrides only **local** config, never secrets. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-config-go` | The non-secret typed-config mechanism secrets build on | +| `golem-add-agent-go` | Define the base agent the config attaches to | +| `golem-call-another-agent-go` | Understand why secrets are not overridable over RPC | diff --git a/golem-skills/skills/go/golem-add-transactions-go/SKILL.md b/golem-skills/skills/go/golem-add-transactions-go/SKILL.md new file mode 100644 index 0000000000..7b71d2130c --- /dev/null +++ b/golem-skills/skills/go/golem-add-transactions-go/SKILL.md @@ -0,0 +1,188 @@ +--- +name: golem-add-transactions-go +description: "Adding saga-pattern transactions with compensation to a Go Golem agent. Use when the user asks about transactions, sagas, compensation, rollback, Operation/Step, FallibleTransaction, InfallibleTransaction, or multi-step operations that need undo logic in a Go Golem project." +--- + +# Saga-Pattern Transactions (Go) + +## Overview + +Golem supports the **saga pattern** for multi-step operations where each step has a +compensation (undo). If a later step fails, the steps that already succeeded are +compensated in **reverse order**. The saga helpers build on the durability +primitives (an atomic region + the oplog) — no persistence beyond what the runtime +already provides. + +> **Steps that call HTTP.** A transaction runs its steps inside an atomic region, +> and an outgoing HTTP request (`net/http`) does not yet settle inside one — the +> region fails to close with *"non-re-executable durable calls initiated in it are +> still in flight"*. Cross-agent RPC is unaffected, so today a step should do its +> external work through RPC to an agent that owns the HTTP call. + +The Go API lives in the `golem` package: + +- `golem.Operation[In, Out, E]` — a compensable step, built with `golem.NewOperation`. +- `golem.Step(tx, op, input)` — run an operation inside a transaction (a **free + function**, because Go methods cannot take type parameters). +- `golem.FallibleTransaction[Out, E](...)` — rolls back on failure and **returns** a + `golem.TransactionFailure[E]`. +- `golem.InfallibleTransaction[Out, E](...)` — rolls back and **retries** the whole + transaction until it succeeds. + +Expected step failures are modeled as the **error arm** of a `golem.Result` (type +`E`, often `string`). A `panic` is an infra failure: it leaves the atomic region +open so the runtime replays it. + +## Steps + +1. **Define each operation** with `golem.NewOperation(execute, compensate)`. +2. **Choose a transaction flavor** — fallible (failure is acceptable) or infallible (must eventually succeed). +3. **Run the steps** with `golem.Step(tx, op, input)` inside the transaction body. +4. **Handle the outcome** — inspect the `golem.Result` (fallible) or use the returned value (infallible). + +## Defining Operations + +An operation pairs an `execute` action with the `compensate` that undoes it. +`execute` is `func(In) golem.Result[Out, E]`; `compensate` receives **both** the +original input and the output `execute` produced, and returns +`golem.Result[golem.Unit, E]`. Compensation runs only if a later step fails. + +```go +import "github.com/golemcloud/golem/sdks/go/golem" + +// Reserve inventory; compensation cancels the reservation. E is string here. +var reserveInventory = golem.NewOperation( + func(sku string) golem.Result[string, string] { + reservationID, err := callInventoryAPI(sku) + if err != nil { + return golem.Err[string, string](err.Error()) + } + return golem.Ok[string, string](reservationID) + }, + func(sku, reservationID string) golem.Result[golem.Unit, string] { + if err := cancelReservation(reservationID); err != nil { + return golem.Err[golem.Unit, string](err.Error()) + } + return golem.Ok[golem.Unit, string](golem.Unit{}) + }, +) + +var chargePayment = golem.NewOperation( + func(amount int64) golem.Result[string, string] { + chargeID, err := callPaymentAPI(amount) + if err != nil { + return golem.Err[string, string](err.Error()) + } + return golem.Ok[string, string](chargeID) + }, + func(amount int64, chargeID string) golem.Result[golem.Unit, string] { + if err := refundPayment(chargeID); err != nil { + return golem.Err[golem.Unit, string](err.Error()) + } + return golem.Ok[golem.Unit, string](golem.Unit{}) + }, +) +``` + +## Fallible Transactions + +On a step failure, the completed steps are compensated (best-effort, in reverse) +and a `golem.TransactionFailure[E]` is returned — **there is no retry**. Run steps +with `golem.Step(tx, op, input)`; return an error result from the body to trigger +rollback. + +```go +result := golem.FallibleTransaction(func(tx *golem.Transaction[string]) golem.Result[string, string] { + r1 := golem.Step(tx, reserveInventory, "SKU-123") + if r1.IsErr() { + return golem.Err[string, string](r1.Err()) + } + r2 := golem.Step(tx, chargePayment, 4999) + if r2.IsErr() { + return golem.Err[string, string](r2.Err()) + } + // Combine the two outputs into the transaction's result value. + return golem.Ok[string, string](r1.Ok() + ":" + r2.Ok()) +}) + +if result.IsErr() { + f := result.Err() // golem.TransactionFailure[string] + _ = f.Error // the step failure that aborted the transaction + if !f.RolledBackFully() { + // A compensation itself failed — some effects may remain (needs attention). + _ = f.CompensationFailure // golem.Option[string], Some(...) here + } +} else { + orderID := result.Ok() + _ = orderID +} +``` + +`golem.TransactionFailure[E]` fields: + +- `Error E` — the step failure that aborted the transaction. +- `CompensationFailure golem.Option[E]` — `Some(...)` if a compensation itself + failed during rollback (a **partial** rollback); `None` if every compensation + succeeded. +- `RolledBackFully() bool` — true when the rollback was complete. + +## Infallible Transactions + +On a step failure, the completed steps are compensated in reverse, the oplog is +rewound to the transaction start, and the runtime **replays the whole +transaction** — so it returns the plain `Out` value, always succeeding eventually: + +```go +orderID := golem.InfallibleTransaction(func(tx *golem.Transaction[string]) golem.Result[string, string] { + r1 := golem.Step(tx, reserveInventory, "SKU-123") + if r1.IsErr() { + return golem.Err[string, string](r1.Err()) + } + r2 := golem.Step(tx, chargePayment, 4999) + if r2.IsErr() { + return golem.Err[string, string](r2.Err()) + } + return golem.Ok[string, string](r1.Ok() + ":" + r2.Ok()) +}) +// orderID is a plain string — the transaction retried until it succeeded. +``` + +Use `InfallibleTransaction` only when the steps are expected to **eventually +succeed** — a deterministic failure would retry forever. If a compensation itself +fails during a rollback-for-retry, the transaction cannot be made consistent and +the helper **panics** (surfacing which compensation failed). + +## Not available in the Go SDK + +The Rust SDK splits operations into `sync_operation` and `operation` (async), and +its transactions are `async` and require wrapping bodies in `boxed(async move { … +})`. The Go SDK has **none of that** — there is a single `golem.NewOperation`, and +transaction bodies are plain synchronous functions. Blocking work inside a step +(HTTP, RPC, promises) suspends the fiber at its await point, so no `async`/`boxed` +plumbing is needed. `golem.Step` is a top-level function (not a method on the +transaction) because Go methods cannot carry the per-step type parameters. + +## Guidelines + +- Model expected step failures as the **error arm** of the step's `golem.Result`; + reserve `panic` for infra failures (it leaves the region open for replay). +- Run every step with `golem.Step(tx, op, input)` — that is what records the + compensation to run on rollback. +- Keep compensation logic **idempotent** — it may run more than once (especially + under `InfallibleTransaction`). +- Compensation runs in **reverse** order of execution. +- All steps in one transaction share the error type `E` (commonly `string`). +- Use `FallibleTransaction` when failure is an acceptable outcome; + `InfallibleTransaction` when the operation must eventually succeed. +- A transaction opens a **worker-global** atomic region — keep the whole + transaction on one logical flow; don't run concurrent goroutines that perform + durable side effects while it is open. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-atomic-block-go` | The atomic-region / durability primitives transactions build on | +| `golem-call-another-agent-go` | Steps that call other agents via RPC | +| `golem-make-http-request-go` | Steps that call external HTTP APIs | +| `golem-retry-policies-go` | Tune how failing steps/operations are retried | diff --git a/golem-skills/skills/go/golem-add-webhook-go/SKILL.md b/golem-skills/skills/go/golem-add-webhook-go/SKILL.md new file mode 100644 index 0000000000..aae275935d --- /dev/null +++ b/golem-skills/skills/go/golem-add-webhook-go/SKILL.md @@ -0,0 +1,144 @@ +--- +name: golem-add-webhook-go +description: "Receiving external webhook callbacks in a Go Golem agent. Use when the user asks to create webhooks, receive webhook callbacks, integrate with webhook-driven external APIs, or generate temporary callback URLs for external services in a Go Golem project." +--- + +# Using Webhooks in a Go Golem Agent + +## Overview + +A Golem webhook lets an agent mint a temporary public URL that an external system POSTs to; the POST body is delivered back to the agent. Under the hood a webhook **is a Golem promise**: the agent durably suspends while awaiting the callback, consuming no resources, and survives restarts (exactly-once via oplog replay). + +In Go there is no standalone `create_webhook` helper — you drive it through the promise API in `golem/promise.go`: + +- `golem.NewPromise[T]()` creates a promise owned by the current agent. +- `p.WebhookURL()` mints the external URL that completes that promise on POST. +- `p.ID()` returns the `golem.PromiseID` to persist in agent state. +- `golem.PromiseByID[T](id).Await()` (or `p.Await()`) suspends until the POST arrives and returns the body decoded as `T`. + +This is useful for payment gateways, CI/CD, GitHub/Stripe callbacks, and any event-driven workflow where an external system notifies the agent. + +### Prerequisites + +The agent type **must** have an HTTP mount (`Spec.HTTP = &golem.Mount{Path: "/..."}`) and be deployed via an `httpApi` deployment in `golem.yaml`. Without that, `WebhookURL()` traps (it is fail-loud). The mount does not need any HTTP endpoints — it only makes the agent HTTP-API-deployable. + +## Steps + +1. **Add an HTTP mount** to the agent's `Spec` (see `golem-add-http-endpoint-go`). +2. **Create a promise** and mint its webhook URL; persist the `PromiseID` in state and return/share the URL. +3. **Await the callback** in a later invocation via the stored id. +4. **Deploy** behind an `httpApi` so the URL is reachable. + +## API + +| Function / method | Description | +|---|---| +| `golem.NewPromise[T]()` | Create a promise owned by the current agent; returns `*golem.Promise[T]` | +| `(*Promise[T]).WebhookURL() string` | Mint the public URL that a POST completes; requires the agent be HTTP-API-deployed | +| `(*Promise[T]).ID() golem.PromiseID` | The durable id — persist it to await/complete in a later invocation | +| `(*Promise[T]).Await() T` | Suspend until completed; returns the POST body decoded as `T` (JSON, or raw bytes when `T` is `[]byte`) | +| `golem.PromiseByID[T](id)` | Rebuild a handle from a stored `PromiseID` | +| `golem.CompletePromise[T](id, value)` | Complete a promise from *another agent* (external completers use the URL instead) | + +## Complete example + +### Definition (`agents/webhookdemo/webhookdemo.go`) + +```go +// Package webhookdemo is the DEFINITION of a webhook agent. It needs the HTTP +// mount below (plus an httpApi deployment) or WebhookURL() traps. +package webhookdemo + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Queue string } // bound by {queue} in the mount path + +// Event is the webhook payload — JSON tags are the contract for the caller's POST. +type Event struct { + OrderID string `json:"orderId"` + Amount int64 `json:"amount"` +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "WebhookDemoAgent", + Description: "Completes a promise from an external webhook POST", + HTTP: &golem.Mount{Path: "/hooks/{queue}"}, // makes the agent HTTP-API-deployable +}) + +var ( + Open = golem.DefineMethod[ID, golem.Unit, string]("open", + golem.Desc("Create a promise and return its webhook URL")) + Result = golem.DefineMethod[ID, golem.Unit, Event]("result", + golem.Desc("Await the payload POSTed to the webhook URL")) +) +``` + +### Implementation (`agents/webhookdemo/impl/impl.go`) + +```go +package impl + +import ( + "myapp/agents/webhookdemo" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct { + pending golem.PromiseID + open bool +} + +var agent = golem.Implement(webhookdemo.Agent, func(webhookdemo.ID) *state { return &state{} }) + +func init() { + // Mint a URL; persist the PromiseID so a later invocation can await it. + golem.Handle(agent, webhookdemo.Open, func(ctx *golem.Context[state], _ golem.Unit) string { + p := golem.NewPromise[webhookdemo.Event]() + ctx.State.pending = p.ID() + ctx.State.open = true + return p.WebhookURL() // hand this URL to the external system + }) + + // Suspend until the external POST arrives; returns the decoded body. + golem.Handle(agent, webhookdemo.Result, func(ctx *golem.Context[state], _ golem.Unit) webhookdemo.Event { + if !ctx.State.open { + panic("no open webhook — call open first") + } + return golem.PromiseByID[webhookdemo.Event](ctx.State.pending).Await() + }) +} +``` + +## Payload decoding + +`Await()` decodes the POST body as its type parameter `T` via JSON. Use a struct with `json` tags (as `Event` above) for structured payloads, or `golem.PromiseByID[[]byte](id).Await()` to receive the raw request bytes unchanged. + +## Webhook URL structure and suffix + +The minted URL has the shape `https://///`: + +- `` — where the HTTP API is deployed. +- `` — defaults to `/webhooks`, customizable via `webhookUrl` in the `httpApi` deployment section of `golem.yaml`. +- `` — defaults to the agent type name in kebab-case; override it with `Mount.WebhookSuffix`. +- `` — a unique per-webhook identifier. + +```go +HTTP: &golem.Mount{Path: "/api/orders/{id}", WebhookSuffix: "/workflow-hooks"}, +``` + +## Key Constraints + +- The agent **must** set `Spec.HTTP` and be deployed via `httpApi`, or `WebhookURL()` traps (it is fail-loud, surfacing an agent-error). +- Only the agent that created the promise may `Await` it; awaiting from another agent traps in the host. +- Only a `POST` to the URL completes the promise; the URL is one-shot — once completed it is invalid, and a later `Await` returns the recorded body from the oplog. +- The agent is durably suspended while awaiting — it survives failures, restarts, and updates. +- **Go difference from Rust:** `Mount.WebhookSuffix` must be **literal segments only** — path variables like `{agent-type}` or `{name}` in the suffix are rejected in the Go SDK (the Rust `webhook_suffix` allows them). + +### Related Skills + +| Skill | When to Load | +|---|---| +| `golem-add-http-endpoint-go` | Set up the HTTP mount + `httpApi` deployment webhooks require | +| `golem-add-agent-go` | Define the agent and its payload types | +| `golem-add-http-auth-go` | Require authentication on the agent's other endpoints | diff --git a/golem-skills/skills/go/golem-annotate-agent-go/SKILL.md b/golem-skills/skills/go/golem-annotate-agent-go/SKILL.md new file mode 100644 index 0000000000..fb0523eba7 --- /dev/null +++ b/golem-skills/skills/go/golem-annotate-agent-go/SKILL.md @@ -0,0 +1,131 @@ +--- +name: golem-annotate-agent-go +description: "Configuring a Go agent's definition — name, description, mode, HTTP mount, and method descriptions. Use when the user asks to set an agent's name/description, make it durable or ephemeral, mount it under an HTTP path, or add descriptions to agent methods for metadata/LLM discovery in a Go Golem project." +--- + +# Configuring a Go Agent's Definition + +## Overview + +An agent's **definition** carries all of its declarative metadata. In Go there are no attribute macros — the metadata is plain values you pass to `golem.DefineAgent`: + +- the `golem.Spec` struct — `Name`, `Description`, `Mode`, `HTTP` (mount), and `Snapshot`; +- per-method options passed to `golem.DefineMethod` — `golem.Desc(...)` for a method description and `golem.HTTP(...)` for HTTP routes. + +This metadata is surfaced in the published agent-type schema (used by the platform, by other agents, and by metadata/LLM tool discovery). It has no effect on the handler logic itself. + +## Steps + +1. **Set identity + mode** on the `Spec`: `Name`, `Description`, and (optionally) `Mode`. +2. **Describe each method** with the `golem.Desc("...")` option on `golem.DefineMethod`. +3. **Mount over HTTP** (optional) by setting `Spec.HTTP` and adding `golem.HTTP(...)` routes to methods. +4. **Build** — run `golem build`. + +## Spec fields (`agents/inventory/inventory.go`) + +```go +// Package inventory is the DEFINITION of the inventory agent. +package inventory + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID holds the constructor parameters and is the agent's type-level identity. +type ID struct{ WarehouseID string } + +type RestockIn struct { + SKU string + Quantity uint32 +} + +type PickIn struct { + SKU string + Quantity uint32 +} + +// Agent is the state-free definition. All declarative metadata lives on Spec. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "InventoryAgent", + Description: "Tracks per-warehouse stock levels", + Mode: golem.Durable, // default; state persists and replays deterministically +}) +``` + +`golem.Spec` (see `sdks/go/golem/golem.go:160`) has these fields: + +| Field | Type | Meaning | +|-------|------|---------| +| `Name` | `string` | Wire-level agent type name, as seen by the platform and other agents. **Required.** | +| `Description` | `string` | Free-text description surfaced in the agent-type metadata. | +| `Mode` | `golem.Mode` | `golem.Durable` (default) or `golem.Ephemeral`. | +| `HTTP` | `*golem.Mount` | When set, mounts the agent's methods under an HTTP path prefix (see below). | +| `Snapshot` | `golem.SnapshotPolicy` | Snapshot cadence; zero value disables snapshotting. | + +### Mode + +- **`golem.Durable`** — the default (`Mode` zero value). State persists across invocations and replays deterministically on recovery. +- **`golem.Ephemeral`** — no state is persisted across invocations. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "StatelessScorer", + Mode: golem.Ephemeral, +}) +``` + +## Describing methods + +Attach `golem.Desc("...")` to a method to set the description carried in the schema. Setting it more than once for the same method is a **definition error**, not a silent overwrite. + +```go +var ( + CheckStock = golem.DefineMethod[ID, string, uint32]("check-stock", + golem.Desc("Returns the number of units in stock for the given SKU; 0 if unknown.")) + + Restock = golem.DefineMethod[ID, RestockIn, uint32]("restock", + golem.Desc("Increases the stock count for the given SKU by the amount; returns the new total.")) + + // Model an observable failure in the result type, and describe it. + Pick = golem.DefineMethod[ID, PickIn, golem.Result[uint32, string]]("pick", + golem.Desc("Decreases stock for the given SKU; returns err if there is insufficient stock.")) +) +``` + +Method options compose — pass several in one `DefineMethod` call (e.g. `golem.Desc(...)` together with `golem.HTTP(...)` or `golem.ReadOnly()`). + +## Mounting over HTTP + +Set `Spec.HTTP` to a `*golem.Mount` and add `golem.HTTP(...)` routes per method. Every `ID` field must appear as a `{var}` in the mount path so the platform can identify the instance. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "InventoryAgent", + Description: "Tracks per-warehouse stock levels", + HTTP: &golem.Mount{ + Path: "/warehouses/{warehouseID}", // {warehouseID} binds ID.WarehouseID + CORS: []string{"*"}, + }, +}) + +var CheckStock = golem.DefineMethod[ID, string, uint32]("check-stock", + golem.Desc("Returns units in stock for the given SKU."), + golem.HTTP(golem.GET("/stock/{sku}"))) +``` + +`golem.Mount` fields (`sdks/go/golem/http_mount.go:46`): `Path` (required), `Auth`, `CORS`, `PhantomAgent`, `WebhookSuffix`. Verb constructors are `golem.GET/POST/PUT/DELETE/PATCH/...` and `golem.Custom("VERB", "/path")`. For full route-binding rules (path/query/header/body, per-route auth and CORS) load `golem-add-http-endpoint-go`. + +## Key Constraints + +- `Spec.Name` is **required** and is the wire-level type name — keep it stable, other agents address this agent by it. +- `Mode` defaults to `golem.Durable` (the zero value); set `golem.Ephemeral` only for stateless agents. +- `golem.Desc(...)` and `golem.HTTP(...)` are **definition-side** metadata on `DefineMethod`; they never change handler behavior. +- Setting `Desc` more than once on one method is a definition error reported at discovery. +- There is **no separate "prompt" annotation** in the Go SDK today. Unlike Rust's `#[prompt]`/`#[description]` pair, Go exposes only the single `Description`/`Desc` text (the schema's prompt-hint field is always emitted empty; see `sdks/go/golem/schema.go:196`). Put the LLM-facing guidance in the description. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Create the agent's definition + implementation from scratch | +| `golem-add-http-endpoint-go` | Full HTTP mount/route binding rules (path/query/header/body, auth, CORS) | +| `golem-mark-read-only-go` | Mark a method read-only and configure result caching | +| `golem-configure-durability-go` | Tune durability/retry behavior for a durable agent | diff --git a/golem-skills/skills/go/golem-atomic-block-go/SKILL.md b/golem-skills/skills/go/golem-atomic-block-go/SKILL.md new file mode 100644 index 0000000000..8c022e749c --- /dev/null +++ b/golem-skills/skills/go/golem-atomic-block-go/SKILL.md @@ -0,0 +1,197 @@ +--- +name: golem-atomic-block-go +description: "Using atomic regions, custom durable operations (DurableOp), idempotence mode, oplog commit, and durable idempotency keys in a Go Golem project. Use when the user asks about Atomically, DurableOp / custom durability, idempotence mode, oplog commit, or generating an idempotency key in a Go Golem project." +--- + +# Atomic Regions and Durability Controls (Go) + +## Overview + +Golem provides **automatic durable execution** — all agents are durable by +default. The helpers in this skill are **advanced controls** that most agents +never need. Reach for them only when you have a specific requirement around +atomicity, idempotency, or oplog replication. + +They live in the `golem` package (`golem.Atomically`, `golem.WithIdempotenceMode`, +`golem.OplogCommit`, `golem.GenerateIdempotencyKey`) +and are thin, **fail-loud** wrappers over host functions: on a host failure they +trap and surface as an agent-error — there is no in-band error return. + +> **Concurrency note.** These knobs apply at the **worker level**, not per +> goroutine. Golem runs an agent single-threaded with cooperative task-switching +> only at await points (RPC, promise, sleep). A scope is safe as long as you don't +> hold it open across a concurrent await (e.g. a `CallAsync` fan-out); nesting on a +> single logical flow is fine. + +## Atomic Regions + +Group **external, observable side effects** (RPC to other agents, and other +durable host calls) so that on a crash the whole group replays together. If the agent +fails partway through, recovery re-executes the **entire** region from the start — +so effects performed before the crash happen again (all-or-nothing). + +`golem.Atomically(f func())` runs `f` as one region: on normal return it commits; +if `f` **panics**, the region stays open and the runtime re-executes the whole +region on retry. Panicking is therefore the way to abort a region, consistent with +the fail-loud model. + +`f` takes no arguments and returns nothing — **return a value by capturing it in +an outer variable**: + +```go +// Reserve inventory and charge the customer — if we crash between them, we want +// recovery to re-run BOTH calls, not skip the reservation. +var orderID string +golem.Atomically(func() { + reservation := inventory.Reserve.Call(invClient, inventory.ReserveIn{Item: item, Qty: qty}) + charge := payment.Charge.Call(payClient, payment.ChargeIn{Customer: cust, Amount: price}) + orderID = combine(reservation, charge) +}) +``` + +> **What this is NOT.** `Atomically` is not an STM/transaction primitive and not +> for grouping in-memory state mutations. Agents are single-threaded and in-memory +> state is rebuilt by oplog replay on recovery, so wrapping plain in-memory updates +> does nothing useful: +> +> ```go +> // DON'T. The oplog already rebuilds these deterministically on replay. +> golem.Atomically(func() { +> ctx.State.balance -= amount +> ctx.State.lastTx = now +> }) +> ``` +> +> It is also **not** how you shrink the oplog or speed up recovery — for that use +> snapshots (see `golem-configure-durability-go`). Use `Atomically` only when you +> have **two or more external side effects** that must not be left half-applied +> across a crash. For compensating multi-step workflows, prefer the saga helpers in +> `golem-add-transactions-go`, which build on this primitive. + +> **Outgoing HTTP inside a region.** Cross-agent RPC works inside `Atomically`, as +> above. An outgoing HTTP request (`net/http`) does not yet: the region fails to +> close with *"non-re-executable durable calls initiated in it are still in +> flight"*. Until that is resolved, make HTTP calls outside the region — or reach +> for them through RPC to an agent that owns the call. + +## Custom Durability for Libraries + +The low-level `golem:durability@1.6.0` interface is for **SDK and library authors**, +not an application tuning knob. It lets a library record several raw host effects +as one custom durable operation. `golem.DurableOp[In, Out]` owns the live +invocation: on the live path it runs the body, encodes and persists the typed +result, and returns it; on replay it returns the recorded result **without +running the body**. + +```go +result := golem.DurableOp( + golem.DurableSpec{ + Interface: "my-lib", + Function: "fetch", + Type: golem.WriteRemote, // commit/replay policy + }, + request, // recorded alongside the result, so the oplog is self-describing + func() FetchResult { // runs only on the live path + return doRawSideEffect(request) + }, +) +``` + +Failure has two distinct channels: + +- **Return a value** to record the outcome. If `Out` is a `golem.Result[Ok, Err]`, + an `Err` is a *recorded durable failure* — persisted and replayed like any other + value, so the operation is **not** retried. There is no separate fallible API: + the general schema codec already encodes `golem.Result` as a WIT `result`. +- **Panic** for a transient defect: the unfinished invocation is dropped without an + `End`, so recovery **re-executes** the whole body. Use `panic` / `golem.Must` + when the effect should be retried rather than recorded. + +`Type` (`golem.DurableFunctionType`) picks the commit/replay policy: `ReadLocal`, +`WriteLocal`, `ReadRemote`, `WriteRemote` (the usual choice for an external side +effect), or `WriteRemoteBatched(begin...)` / `WriteRemoteTransaction(begin...)` to +group writes. Set `DurableSpec.ForcedCommit` to force an efficient oplog commit at +the end. There is no async variant — a blocking body already suspends the fiber. + +Make repeated attempts safe: choose the correct `Type` classification, use external +idempotency keys, or wrap the work in a transaction (`golem-add-transactions-go`). + +## Idempotence Mode + +`golem.WithIdempotenceMode(idempotent)` sets the mode and returns a `restore` +function; scope it with `defer`. The **default is `true`** — side effects are +treated as idempotent and Golem gives at-least-once semantics: + +```go +// Opt OUT of the default for a specific block — treat the effect as +// non-idempotent (at-most-once): the agent fails if it is unknown whether the +// side effect already ran, rather than risk running it twice. +func() { + defer golem.WithIdempotenceMode(false)() + // a non-idempotent side effect whose accidental duplication is worse than + // missing it entirely +}() +``` + +Use `false` only when accidental duplication of a side effect would be more +harmful than missing the call. + +## Durable Idempotency Key + +`golem.GenerateIdempotencyKey()` returns a `golem.UUID` that is **stable across +replay** — it is persisted and committed, so you can hand it to a third-party +system (e.g. a payment processor) to make an external call idempotent: + +```go +key := golem.GenerateIdempotencyKey() +// key.String() is stable across restarts — safe as a payment idempotency key +resp := payment.Charge.Call(client, payment.ChargeIn{Amount: amt, Key: key.String()}) +``` + +## Oplog Commit + +`golem.OplogCommit(replicas uint8)` 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: + +```go +golem.OplogCommit(3) // ensure the oplog is replicated to 3 replicas before proceeding +``` + +## Retry policy for a block + +There is no `WithRetryPolicy` in the `golem` package. To override retry behavior +for a scope, use the `retry` subpackage — `retry.With(...)` applies a named rule +for the current call and restores the previous one on return. See +`golem-retry-policies-go`. + +## Not available in the Go SDK + +The Rust SDK exposes separate `_async` variants (`atomically_async`, +`with_idempotence_mode_async`, `with_retry_policy_async`). The Go SDK has **no +async variants** — Go does not +split sync/async APIs. `golem.Atomically` takes a plain `func()`, and the +idempotence scope is `defer`-based; blocking operations (RPC, HTTP, promises) +already suspend the fiber at their await points, so a single API covers both +cases. + +## Key Constraints + +- `golem.Atomically` takes `func()` and returns nothing — capture results in an + outer variable; abort by panicking. +- `WithIdempotenceMode` returns a `restore func()` — call it (usually via + `defer`) or the scope never ends. +- These knobs are **worker-global**, not per-goroutine — don't hold a scope open + across a concurrent await. +- Failures trap and surface as agent-errors; there is no error return value. +- `GenerateIdempotencyKey` is the only helper that returns a value + (`golem.UUID`); the rest return nothing or a `restore` closure. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-transactions-go` | Multi-step workflows with compensation (saga), built on atomic regions | +| `golem-retry-policies-go` | Override retry behavior for a scope (`retry.With`) | +| `golem-configure-durability-go` | Reduce oplog/replay cost with snapshots; choose durable vs ephemeral | +| `golem-make-http-request-go` | The outgoing calls you typically wrap in an atomic region | diff --git a/golem-skills/skills/go/golem-call-another-agent-go/SKILL.md b/golem-skills/skills/go/golem-call-another-agent-go/SKILL.md new file mode 100644 index 0000000000..215946c39f --- /dev/null +++ b/golem-skills/skills/go/golem-call-another-agent-go/SKILL.md @@ -0,0 +1,111 @@ +--- +name: golem-call-another-agent-go +description: "Calling one Go agent from another via typed RPC. Use when the user asks to invoke, call, or communicate with another agent, do agent-to-agent RPC, or await a result from another agent in a Go Golem project." +--- + +# Calling Another Agent (RPC) in Go + +## Overview + +Agents talk to each other through the callee's **definition** package. You get a typed client from `Agent.Get(id)` and call a method descriptor on it. The caller imports only the callee's **definition** package (its `ID`, its method descriptors) — never its `impl` — so the two implementations never form a Go import cycle. + +Calls are durable: results are recorded in the oplog and replayed after a restart rather than re-issued. + +## Steps + +1. **Import the callee's definition package** (e.g. `myapp/agents/ledger`). +2. **Get a client** for a specific instance: `ledger.Agent.Get(ledger.ID{Region: "eu"})`. +3. **Call a method descriptor** on the client: `ledger.Record.Call(client, ledger.RecordIn{Amount: 10})`. +4. If the method returns a `golem.Result`, unwrap it (`.MustOk()` or inspect it). + +## Synchronous call + +```go +package impl + +import ( + "myapp/agents/ledger" + "myapp/agents/rpccaller" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(rpccaller.Agent, func(rpccaller.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, rpccaller.Call, func(_ *golem.Context[state], in rpccaller.CallIn) int64 { + // Get a client for the ledger instance identified by region. + c := ledger.Agent.Get(ledger.ID{Region: in.Region}) + // Call returns the method's Out; here Out is a golem.Result, unwrapped with MustOk. + return ledger.Record.Call(c, ledger.RecordIn{Amount: in.Amount}).MustOk() + }) +} +``` + +`Call` blocks until the callee returns. Because a single agent processes invocations sequentially, a **synchronous self-call** (calling back into the same instance) would deadlock — use `Trigger`/`Schedule` for self-messaging (see `golem-recurring-task-go`). + +### Plain vs Result returns + +`Call` returns the method's declared output type **directly**. Only unwrap when that type is a `golem.Result` — don't append `.MustOk()` to a plain return: + +```go +// greeter.Hello returns a plain string → use it directly +greeting := greeter.Hello.Call(c, greeter.HelloIn{Name: "alice"}) + +// ledger.Record returns golem.Result[int64, string] → unwrap +total := ledger.Record.Call(c, ledger.RecordIn{Amount: 10}).MustOk() +``` + +## Asynchronous call + +Start the call, do other work, then await: + +```go +fut := ledger.Record.CallAsync(c, ledger.RecordIn{Amount: in.Amount}) // *golem.Future[Out] +// ... other work ... +total := fut.Get().MustOk() // Get() blocks for the result +``` + +Launch several and await them to fan out work across other agents. + +## Unwrapping a `golem.Result` + +When a method's output is `golem.Result[Ok, Err]`: + +```go +res := ledger.Record.Call(c, in) // golem.Result[int64, string] +switch { +case res.IsErr(): + // handle the domain error value + msg := res.Err() + _ = msg +default: + total := res.Ok() + _ = total +} + +// Or fail loud (panic on Err, which the SDK turns into an agent-error): +total := ledger.Record.Call(c, in).MustOk() +``` + +## Import-cycle rule (important) + +- **impl packages never import each other.** All cross-agent references go through the callee's **definition** package, which imports only the SDK. +- This keeps the import graph a DAG no matter how cyclic the *call* graph is (A↔B mutual calls are fine as long as each impl imports the other's def, not its impl). + +## Key Constraints + +- You call `Method.Call(client, in)` (not `client.Call(method, in)`): the method descriptor carries the input/output types. Same for `Trigger`, `Schedule`, `CallAsync`. +- The client comes from the **definition** (`Def.Agent.Get(id)`); the ID is encoded from the `ID` type, so the caller does not need the callee locally registered. +- Don't hold a `*golem.Future` across invocations — await it (`Get()`) within the same handler. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-fire-and-forget-go` | Enqueue a call without awaiting a result (`Trigger`) | +| `golem-recurring-task-go` | An agent messages itself / schedules future work | +| `golem-multi-instance-agent-go` | Address a specific instance (or a phantom) by ID | +| `golem-add-agent-go` | Define the agent being called | diff --git a/golem-skills/skills/go/golem-call-from-external-go/SKILL.md b/golem-skills/skills/go/golem-call-from-external-go/SKILL.md new file mode 100644 index 0000000000..2efc151765 --- /dev/null +++ b/golem-skills/skills/go/golem-call-from-external-go/SKILL.md @@ -0,0 +1,132 @@ +--- +name: golem-call-from-external-go +description: "Invoking Go Golem agents from outside the platform — the CLI, an HTTP client, or the worker REST API. Use when the user wants to call, invoke, or drive agents from outside Golem: a Go CLI, a server, a script, curl, or any external application, in a Go Golem project." +--- + +# Calling Go Agents from Outside Golem + +## Overview + +Agents defined with the Go SDK are reached from outside the platform through **language-agnostic** entry points: + +1. **The `golem` CLI** — `golem agent invoke` calls a method and waits for the result. +2. **HTTP endpoints** — if the agent declares an HTTP mount, external clients (including a Go `net/http` client) call its methods over plain HTTP. +3. **The worker REST API** — invoke methods and complete promises directly over HTTP against the Golem server. + +> **No Go bridge SDK.** The `bridge:` generator produces typed external client crates/packages for TypeScript, Rust, MoonBit, and Scala — there is **no Go external bridge generator**. From an external **Go** program, call agents over the REST API or the agent's HTTP endpoints with the standard library (`net/http`), as shown below. + +Throughout, the example is a `CounterAgent` whose Go `ID` is `struct{ Name string }` with methods `increment`, `add`, and `value`. + +## Approach 1: the CLI + +`golem agent invoke` calls a method on a deployed agent and blocks for the result. The agent is created automatically on first invocation. Both `golem` and `golem-cli` work for every command. + +```shell +golem agent invoke [ARGUMENTS...] +``` + +### Agent ID format + +The agent ID is the agent type name plus its constructor parameters — the fields of the Go `ID` struct, in declaration order: + +``` +AgentTypeName(param1, param2, ...) +``` + +`CounterAgent`'s `ID` is `struct{ Name string }`, so its ID is `CounterAgent("my-counter")`. A singleton (`type ID struct{}`) uses empty parentheses: `CounterAgent()`. IDs may be prefixed with `env/`, `app/env/`, or `account/app/env/`. + +### Examples + +```shell +# No-parameter method +golem agent invoke 'CounterAgent("my-counter")' increment + +# add takes one parameter (the By field of AddIn), passed positionally +golem agent invoke 'CounterAgent("my-counter")' add 5 + +# Read the current value +golem agent invoke 'CounterAgent("my-counter")' value + +# In a specific environment +golem agent invoke 'staging/CounterAgent("my-counter")' value + +# With an explicit idempotency key +golem agent invoke -i my-unique-key 'CounterAgent("my-counter")' increment + +# Machine-readable output +golem agent invoke --format json 'CounterAgent("my-counter")' value +``` + +### CLI options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | Only trigger the invocation without waiting (fire-and-forget) | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | +| `--schedule-at ` | Schedule the invocation (requires `--trigger`; ISO 8601) | +| `--format json` / `--format yaml` | Machine-readable output | + +Method arguments use the CLI's WIT value syntax: strings quoted (`"my-counter"`), integers bare (`5`), booleans `true`/`false`, options `some(v)`/`none`, results `ok(v)`/`err(v)`, records `{ field-one: 1 }`. Each exported field of a Go input struct is one positional parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). + +## Approach 2: HTTP endpoints + +If the agent declares an HTTP mount, its methods are reachable over plain HTTP from any client. Declare the mount on the `Spec` and per-method routes with `golem.HTTP`: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + HTTP: &golem.Mount{Path: "/counters/{name}"}, // {name} binds the ID field +}) + +var Add = golem.DefineMethod[ID, AddIn, int64]("add", + golem.HTTP(golem.POST("/add?by={by}"))) +``` + +The agent must also be declared in the manifest's `httpApi` deployment. External clients then POST to the deployed route — from a Go program with the standard library: + +```go +resp, err := http.Post( + "https://my-golem.example.com/counters/my-counter/add?by=5", + "application/json", nil, +) +``` + +See `golem-add-http-endpoint-go` for the full mount/route model. + +## Approach 3: the worker REST API + +Call methods (or complete promises) directly against the Golem server over HTTP — usable from any language, including external Go: + +```shell +# Invoke and await a method +curl -X POST \ + "$GOLEM_URL/v1/components/$COMPONENT_ID/workers/$AGENT_ID/invoke-and-await?function=add" \ + -H 'Content-Type: application/json' \ + -d '{"params": [5]}' + +# Complete a promise an agent is awaiting (see golem-wait-for-external-input-go) +curl -X POST \ + "$GOLEM_URL/v1/components/$COMPONENT_ID/workers/$AGENT_ID/complete" \ + -H 'Content-Type: application/json' \ + -d '{"oplogIdx": , "data": []}' +``` + +`$AGENT_ID` is the same `AgentTypeName(params)` string the CLI uses. This is the mechanism a promise's `PromiseID` fields (`ComponentID`, `AgentID`, `OplogIndex`) feed into for external completion. + +## Key Constraints + +- `golem agent invoke` **blocks** until the agent returns; use `-t/--trigger` for fire-and-forget. +- Every invocation carries an idempotency key (auto-generated if not supplied), giving at-most-once execution even if the client retries. +- Constructor arguments in the agent ID must match the Go `ID` struct fields in order. +- There is **no generated Go external client** — from external Go, use the REST API / HTTP endpoints with `net/http`. Typed generated clients exist only for TypeScript, Rust, MoonBit, and Scala via `bridge:`. +- HTTP-endpoint access requires both a `Spec.HTTP` mount and an `httpApi` deployment declaration. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-invoke-agent-go` | Full `golem agent invoke` reference and options | +| `golem-add-http-endpoint-go` | Expose the agent's methods over HTTP | +| `golem-wait-for-external-input-go` | Complete a promise from outside via REST | +| `golem-add-agent-go` | Define the agent being called | diff --git a/golem-skills/skills/go/golem-configure-durability-go/SKILL.md b/golem-skills/skills/go/golem-configure-durability-go/SKILL.md new file mode 100644 index 0000000000..b8c7a3e15a --- /dev/null +++ b/golem-skills/skills/go/golem-configure-durability-go/SKILL.md @@ -0,0 +1,197 @@ +--- +name: golem-configure-durability-go +description: "Choosing between durable and ephemeral agents in a Go Golem project, and adding periodic snapshots. Use when the user asks about agent durability modes, making an agent stateless, configuring agent persistence, or reducing oplog replay cost in a Go Golem project." +--- + +# Configuring Agent Durability (Go) + +## Overview + +Durability is a property of the **agent definition** — it lives on the `golem.Spec` +you pass to `golem.DefineAgent`. There is no attribute or macro; you set two +struct fields: + +- `Mode` — `golem.Durable` (the default) or `golem.Ephemeral`. +- `Snapshot` — a `golem.SnapshotPolicy`, defaulting to `golem.SnapshotDisabled`. + +Nothing in the implementation package changes: handlers are written the same way +regardless of mode. + +## Steps + +1. **Decide the mode** — durable (default) unless the agent is genuinely stateless. +2. **Set `Mode`** on the `golem.Spec` in the definition package (omit it for durable). +3. **Add a snapshot policy** if the oplog would otherwise grow unboundedly. +4. **Build** — run `golem build`. + +## Durable Agents (Default) + +By default every Golem agent is **durable** — `Mode` defaults to `golem.Durable`, +so you never write it explicitly: + +- State persists across invocations, failures, and restarts. +- Every side effect is recorded in an **oplog** (operation log). +- On failure, the agent is transparently recovered by replaying the oplog. +- No special code needed — durability is automatic. + +You **cannot opt out of oplog writes for a durable agent** — the oplog is how +durability works. If oplog volume or replay cost is the concern (long-running +agents, heartbeats, polling, recurring tasks), do not try to skip persistence; +add **periodic snapshots** instead (below). + +```go +// Package counter is the DEFINITION of a standard durable agent. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +// Mode is omitted, so it defaults to golem.Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Description: "A simple durable counter", +}) + +var ( + Increment = golem.DefineMethod[ID, golem.Unit, int64]("increment", golem.Desc("Increase the count by one")) + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", golem.Desc("Return the current value")) +) +``` + +The implementation is ordinary — the private `state` is rebuilt by oplog replay +on recovery: + +```go +package impl + +import ( + "myapp/agents/counter" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ count int64 } + +var agent = golem.Implement(counter.Agent, func(counter.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.count++ + return ctx.State.count + }) + golem.Handle(agent, counter.Value, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.count + }) +} +``` + +## Durable with Periodic Snapshots + +Same durability guarantees as the default, but recovery starts from the **latest +snapshot** instead of replaying the whole oplog. Use this whenever the oplog grows +unboundedly — long-running agents, high-frequency state changes, heartbeats, +polling loops, recurring tasks. + +Set the `Snapshot` field on the `golem.Spec`: + +```go +import "time" + +// Snapshot every 10 invocations. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CounterAgent", + Snapshot: golem.SnapshotEveryN(10), +}) + +// Or at most once per interval. +var HeartbeatAgent = golem.DefineAgent[ID](golem.Spec{ + Name: "HeartbeatAgent", + Snapshot: golem.SnapshotPeriodic(30 * time.Second), +}) + +// Or let the platform pick the cadence. +var PipelineAgent = golem.DefineAgent[ID](golem.Spec{ + Name: "PipelineAgent", + Snapshot: golem.SnapshotDefault, +}) +``` + +The snapshot policy constructors are: + +| Constructor | Meaning | +|---|---| +| `golem.SnapshotDisabled` | The zero value — the platform never snapshots. | +| `golem.SnapshotDefault` | Snapshot at the platform's default cadence. | +| `golem.SnapshotEveryN(n uint16)` | Snapshot every `n` invocations. | +| `golem.SnapshotPeriodic(d time.Duration)` | Snapshot on a fixed time interval. | + +### What gets snapshotted + +Go reflection **cannot see unexported fields**, so the idiomatic private state +(e.g. an unexported `count`) is only captured if the state type implements the +`golem.Snapshotter` interface: + +```go +type Snapshotter interface { + Save() ([]byte, error) + Load([]byte) error +} +``` + +Without a `Snapshotter`, the snapshot is the JSON of the state's **exported** +fields only. If your durable state is unexported (the common case), implement +`Save`/`Load` on the `*state` before relying on snapshots. + +## Ephemeral Agents + +Use **ephemeral** mode for stateless, per-invocation agents where persistence is +not needed: + +- State is discarded after each invocation completes. +- No durable state across invocations — lower overhead. +- Useful for pure functions, request handlers, or adapters. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "StatelessHandler", + Mode: golem.Ephemeral, +}) +``` + +## When to Choose Which + +| Use Case | Mode | +|----------|------| +| Counter, shopping cart, workflow orchestrator | **Durable** (default) | +| Stateless request processor, transformer | **Ephemeral** | +| Long-running saga or multi-step pipeline | **Durable** (default) | +| Pure computation, no side effects worth persisting | **Ephemeral** | +| Agent that calls external APIs with at-least-once semantics | **Durable** (default) | +| Long-running agent with heartbeats, polling, or recurring tasks | **Durable + periodic snapshots** | +| Any durable agent whose oplog grows so large that replay is slow | **Durable + periodic snapshots** | + +When in doubt, use the default (durable). Ephemeral is an optimization for agents +that genuinely don't need persistence; add periodic snapshots whenever recovery +time matters. + +## Key Constraints + +- Mode and snapshot policy are set on the **definition** (`golem.Spec`), not the + implementation — the handler code is identical either way. +- `Mode` defaults to `golem.Durable`; only set it to switch to `golem.Ephemeral`. +- `Snapshot` defaults to `golem.SnapshotDisabled`; snapshots do not change + durability guarantees, only recovery time. +- **Read-only methods require a durable agent** — marking a method on an + `Ephemeral` agent read-only is a definition error (see `golem-mark-read-only-go`). +- Unexported private state is not captured by the default reflective snapshot; + implement `golem.Snapshotter` if you snapshot such an agent. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Define the agent and its methods in the first place | +| `golem-mark-read-only-go` | Add cacheable, side-effect-free query methods (durable only) | +| `golem-atomic-block-go` | Fine-grained persistence / idempotency / atomicity controls | +| `golem-recurring-task-go` | Long-running agents that heartbeat or schedule future work | diff --git a/golem-skills/skills/go/golem-create-agent-instance-go/SKILL.md b/golem-skills/skills/go/golem-create-agent-instance-go/SKILL.md new file mode 100644 index 0000000000..1c1c3a0df5 --- /dev/null +++ b/golem-skills/skills/go/golem-create-agent-instance-go/SKILL.md @@ -0,0 +1,131 @@ +--- +name: golem-create-agent-instance-go +description: "Creating a new Go Golem agent instance with golem agent new. Use when the user asks to create, instantiate, or pre-create an agent without invoking a method in a Go Golem project." +--- + +# Creating a Go Golem Agent Instance with `golem agent new` + +## Overview + +`golem agent new` **creates a new agent instance** without invoking any method on it. The agent is initialized with its constructor parameters and starts in an idle state, ready to receive invocations. + +Unlike `golem agent invoke` — which implicitly creates the agent on first call — `golem agent new` explicitly pre-creates it, which is useful when you need to set environment variables, configuration, or WASI config at creation time. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Choose any creation-time settings** — `--env`, `--config`, `--wasi-config` — if needed. +3. **Run `golem agent new`** to pre-create the instance. +4. **Invoke it later** with `golem agent invoke` using the same agent ID. + +## Usage + +```shell +golem agent new [OPTIONS] +``` + +## Agent ID Format + +The agent ID identifies the agent type and its constructor parameters: + +``` +AgentTypeName(param1, param2, ...) +``` + +For a Go agent, the constructor parameters are the fields of its `ID` struct in declaration order. `CounterAgent`'s `ID` is `struct{ Name string }`, so its ID is `CounterAgent("my-counter")`. For an agent whose `ID` has no fields (a singleton), use empty parentheses: `AgentTypeName()`. + +The agent ID can optionally be prefixed with environment or application paths: + +| Format | Description | +|--------|-------------| +| `AgentTypeName(params)` | Standalone agent name | +| `env/AgentTypeName(params)` | Environment-specific | +| `app/env/AgentTypeName(params)` | Application and environment-specific | +| `account/app/env/AgentTypeName(params)` | Account, application, and environment-specific | + +## Examples + +### Create an agent with constructor parameters + +```shell +golem agent new 'CounterAgent("my-counter")' +``` + +### Create a singleton agent (no constructor parameters) + +```shell +golem agent new 'CounterAgent()' +``` + +### Create an agent with environment variables + +```shell +golem agent new 'CounterAgent("my-counter")' --env API_KEY=sk-abc123 --env LOG_LEVEL=debug +``` + +### Create an agent with configuration + +```shell +golem agent new 'CounterAgent("my-counter")' --config max_retries=5 --config timeout_seconds=30 +``` + +### Create an agent with WASI config + +```shell +golem agent new 'CounterAgent("my-counter")' --wasi-config MY_WASI_VAR=some-value +``` + +### Create an agent in a specific environment + +```shell +golem agent new 'staging/CounterAgent("my-counter")' +``` + +### Combine environment variables and configuration + +```shell +golem agent new 'CounterAgent("my-counter")' \ + --env DATABASE_URL=postgres://... \ + --config batch_size=100 \ + --config retry_policy.max_attempts=3 +``` + +## Available Options + +| Option | Description | +|--------|-------------| +| `-e, --env ` | Environment variables visible to the agent (can be repeated) | +| `-c, --config ` | Configuration entries for the agent, using dot-separated paths (can be repeated). Only configuration declared by the agent can be provided. If not provided, the default from the manifest (`agents.*.config`) is used. | +| `-w, --wasi-config ` | WASI config entries visible to the agent (can be repeated). This is for compatibility with third-party libraries that depend on `wasi:config`; prefer typed configuration (`-c`) for your own agent config. | + +## When to Use `golem agent new` vs `golem agent invoke` + +- Use `golem agent new` when you need to **pre-create** an agent with specific environment variables, configuration, or WASI config before any invocation. +- Use `golem agent invoke` when you want to call a method — the agent is created automatically on first invocation if it doesn't exist. +- An agent created with `golem agent new` can be invoked later with `golem agent invoke` using the same agent ID. + +## Value Syntax + +Agent ID parameters use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Results: `ok(value)` / `err(value)`. +- Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- The constructor arguments must match the fields of the Go `ID` struct in order. +- If the component is not deployed yet and the CLI runs from an application directory, `golem agent new` auto-builds and deploys it before creating the agent. +- Only configuration declared by the agent can be provided via `-c`. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-invoke-agent-go` | Invoke a method on the agent (creates it if absent) | +| `golem-trigger-agent-go` | Fire-and-forget invocation from the CLI | +| `golem-add-agent-go` | Define the agent, its `ID`, and its methods | +| `golem-multi-instance-agent-go` | Address many instances of an agent by ID | diff --git a/golem-skills/skills/go/golem-custom-snapshot-go/SKILL.md b/golem-skills/skills/go/golem-custom-snapshot-go/SKILL.md new file mode 100644 index 0000000000..1f989cb13e --- /dev/null +++ b/golem-skills/skills/go/golem-custom-snapshot-go/SKILL.md @@ -0,0 +1,162 @@ +--- +name: golem-custom-snapshot-go +description: "Enabling snapshot-based recovery and customizing state save/load for Go agents. Use when adding manual update support, custom state serialization, capturing unexported state — or when a long-running Go agent's oplog is growing large and recovery/replay is becoming slow (heartbeats, polling loops, recurring tasks, frequent state changes)." +--- + +# Custom Snapshots in Go + +## Overview + +Snapshotting serializes a running Go agent's state so the host can save it and later restore it. It solves two problems: + +1. **Manual / snapshot-based component updates** — required when updating agents between incompatible component versions. +2. **Fast recovery and oplog compaction** — for long-running agents whose oplog grows over time (heartbeats, polling loops, recurring tasks, frequent state changes). Without snapshotting, every recovery replays the full oplog; with periodic snapshotting, recovery starts from the latest snapshot and replays only what came after it. + +> **You cannot opt out of oplog writes for a durable agent.** If you are worried about oplog volume or replay cost, do *not* try to skip persistence — enable snapshot-based recovery here instead. + +## Two things to set + +1. **A snapshot policy** on the agent's `Spec` — *whether and how often* the platform snapshots. Without a policy, no snapshots are taken. +2. **How the state serializes** — the default (JSON of **exported** fields) or a custom `golem.Snapshotter` implementation (needed for unexported state or a custom/binary format). + +## Step 1: enable a snapshot policy (`Spec.Snapshot`) + +Set `Snapshot` on the agent definition's `Spec`. The zero value is `golem.SnapshotDisabled`. + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "SessionAgent", + Snapshot: golem.SnapshotEveryN(5), // snapshot every 5 invocations +}) +``` + +### Policy builders (from `golem.go`) + +| Builder | Meaning | +|---------|---------| +| `golem.SnapshotDisabled` | Zero value — never snapshot | +| `golem.SnapshotDefault` | Platform's default cadence (**note: the server default may itself be disabled** — prefer an explicit policy) | +| `golem.SnapshotPeriodic(d time.Duration)` | Snapshot at most once per interval | +| `golem.SnapshotEveryN(n uint16)` | Snapshot every `n` invocations (`SnapshotEveryN(1)` = every invocation) | + +```go +Snapshot: golem.SnapshotEveryN(1) // every invocation +Snapshot: golem.SnapshotPeriodic(30 * time.Second) // at most once per 30s +``` + +## Step 2a: automatic (default) snapshotting + +If you set a policy and do nothing else, the SDK JSON-encodes the state's **exported** fields. This is enough when all state you need to preserve lives in exported fields. + +> **Caveat:** Go reflection cannot see **unexported** fields. The idiomatic private state (e.g. an unexported `count`) is invisible to the default snapshot and would be **dropped**. To capture unexported state, implement `golem.Snapshotter` (Step 2b). + +## Step 2b: custom snapshotting (`golem.Snapshotter`) + +Implement `Save`/`Load` on the state type (pointer receiver) when you need to capture unexported fields, use a compact binary format, or migrate between schema versions: + +```go +type Snapshotter interface { + Save() ([]byte, error) + Load([]byte) error +} +``` + +When the state implements `Snapshotter`, its bytes are stored **verbatim** by the host (opaque payload) and handed back on restore — bypassing the reflective JSON path entirely. + +## Full example: session agent with custom snapshot + +### Definition (`agents/session/session.go`) + +```go +// Package session is the DEFINITION of the session agent. Its behaviour, private +// state, and custom snapshot serialization live in the impl subpackage. +package session + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ User string } + +type SpendIn struct{ Amount int64 } + +// Snapshot every 5 invocations instead of the default cadence. Mode defaults to Durable. +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "SessionAgent", + Description: "A session that snapshots its running total every few invocations", + Snapshot: golem.SnapshotEveryN(5), +}) + +var ( + Spend = golem.DefineMethod[ID, SpendIn, int64]("spend", golem.Desc("Add to the running total")) + Total = golem.DefineMethod[ID, golem.Unit, int64]("total", golem.Desc("Return the running total")) +) +``` + +### Implementation (`agents/session/impl/impl.go`) + +```go +// Package impl holds the session agent's private state, method handlers, and +// custom snapshot serialization. Importing it registers the agent. +package impl + +import ( + "encoding/binary" + + "myapp/agents/session" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state keeps a running total in an UNEXPORTED field. Reflection cannot see it, +// so the default snapshot (JSON of exported fields) would drop it — implementing +// golem.Snapshotter below is what makes the state survive. +type state struct{ total int64 } + +// Save/Load make *state a golem.Snapshotter: the returned bytes are stored +// verbatim by the host and handed back on restore, so unexported state is kept. +func (s *state) Save() ([]byte, error) { + b := make([]byte, 8) + binary.LittleEndian.PutUint64(b, uint64(s.total)) + return b, nil +} +func (s *state) Load(b []byte) error { + if len(b) == 8 { + s.total = int64(binary.LittleEndian.Uint64(b)) + } + return nil +} + +var agent = golem.Implement(session.Agent, func(session.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, session.Spend, func(ctx *golem.Context[state], in session.SpendIn) int64 { + ctx.State.total += in.Amount + return ctx.State.total + }) + golem.Handle(agent, session.Total, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.total + }) +} +``` + +## Best practices + +1. **Prefer the default JSON snapshot** unless you have unexported state, need a compact binary format, or need cross-version migration — in those cases implement `Snapshotter`. +2. **Version your format** — include a version byte or tag so `Load` can read snapshots written by an older `Save`. +3. **Keep snapshots small** — large snapshots slow recovery and updates. +4. **Test round-trips** — `Save` → `Load` should reproduce equivalent state (this is native, host-free, so it unit-tests easily). +5. **Handle migration** in `Load` when the schema changes between versions; returning an `error` from `Load` fails a snapshot-based update. + +## Key Constraints + +- A policy is required for snapshots to happen — `Spec.Snapshot` defaults to `SnapshotDisabled`, and `SnapshotDefault` may resolve to the server's default (possibly disabled). Use `SnapshotEveryN` / `SnapshotPeriodic` to guarantee it. +- `Snapshotter` is the **only** way to capture unexported state — the default reflective path sees exported fields only. +- Implement `Save` and `Load` as a pair on the state (usually pointer receiver); the host calls `Save` to capture and `Load` to restore. +- `Save`/`Load` return an `error`; a non-nil `Load` error fails the snapshot-based update. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Define the agent whose state is snapshotted | +| `golem-configure-durability-go` | Other durability controls on an agent | +| `golem-recurring-task-go` | Long-running agents that benefit most from snapshotting | diff --git a/golem-skills/skills/go/golem-enable-otlp-go/SKILL.md b/golem-skills/skills/go/golem-enable-otlp-go/SKILL.md new file mode 100644 index 0000000000..d2d46f8b80 --- /dev/null +++ b/golem-skills/skills/go/golem-enable-otlp-go/SKILL.md @@ -0,0 +1,155 @@ +--- +name: golem-enable-otlp-go +description: "Enabling the OpenTelemetry (OTLP) exporter plugin for a Go Golem agent — exporting traces, logs, and metrics to an OTLP collector via golem.yaml. Use when the user asks to add observability, OpenTelemetry, OTLP, tracing, or metrics export to a Go Golem project." +--- + +# Enabling OpenTelemetry for a Go Agent + +The `golem-otlp-exporter` is a built-in plugin that exports agent telemetry (traces, logs, metrics) to any OTLP-compatible collector via OTLP/HTTP. It runs on the platform side (as an oplog processor), so enabling it is a **manifest concern** — the configuration is the same regardless of the agent's language. No plugin installation is needed; just enable it in `golem.yaml`. + +## Step 1 — Enable the Plugin in golem.yaml + +Add the plugin to the component (or agent) that should emit telemetry: + +```yaml +components: + my-app:service: + plugins: + - name: golem-otlp-exporter + version: "1.5.0" + parameters: + endpoint: "http://localhost:4318" + signals: "traces,logs,metrics" +``` + +### Plugin Parameters + +| Parameter | Required | Description | +|-----------|----------|-------------| +| `endpoint` | Yes | OTLP collector base URL (e.g., `http://localhost:4318`) | +| `signals` | No | Comma-separated: `traces`, `logs`, `metrics`. Default: `traces` | +| `headers` | No | Comma-separated `key=value` HTTP headers (e.g., `x-api-key=secret`) | +| `service-name-mode` | No | `agent-id` (default) or `agent-type` | + +## Step 2 — Deploy + +```shell +golem deploy --yes +``` + +After deployment, newly created agents from this component automatically send telemetry to the configured collector. + +## What Gets Exported + +### Traces + +Spans are created automatically for: +- Agent invocations +- RPC calls to other agents +- Outgoing HTTP requests + +Trace and span IDs propagate from inbound HTTP requests (via code-first routes) and are included in outgoing HTTP request headers automatically. + +> **Custom spans:** the Rust SDK exposes a `golem::api::context` API (`start_span`, attributes, `current_context`) for creating your own spans in guest code. **The Go SDK does not currently expose a public wrapper for this** — the underlying `golem:api/context` bindings exist internally but are not part of the public Go API. Go agents get the automatic invocation/RPC/HTTP spans above; hand-authored custom spans are not available from Go yet. + +### Logs + +When `logs` is included in `signals`, all log output is forwarded to the OTLP collector. Use the standard library `log/slog` — the runtime routes it through the host logging channel and, in turn, to the collector. See the `golem-logging-go` skill for full logging guidance. + +```go +import "log/slog" + +slog.Info("hello from Go") +slog.Debug("this is a debug log entry", "step", 1) +``` + +### Metrics + +When `metrics` is included in `signals`, the following metrics are exported: + +| Metric | Type | Description | +|--------|------|-------------| +| `golem_invocation_count` | Counter | Number of agent method invocations | +| `golem_invocation_duration_ns` | Counter | Invocation duration | +| `golem_invocation_fuel_consumed` | Counter | Fuel consumed by invocations | +| `golem_invocation_pending_count` | Counter | Number of pending invocations | +| `golem_host_call_count` | Counter | Number of internal host calls | +| `golem_log_count` | Counter | Number of log entries emitted | +| `golem_memory_initial_bytes` | Gauge | Initially allocated memory | +| `golem_memory_total_bytes` | Gauge | Total allocated memory | +| `golem_memory_growth_bytes` | Counter | Memory growth since start | +| `golem_component_size_bytes` | Gauge | Component size in bytes | +| `golem_error_count` | Counter | Number of recorded errors | +| `golem_interruption_count` | Counter | Number of interrupt requests | +| `golem_exit_count` | Counter | Number of process exit signals | +| `golem_restart_count` | Counter | Number of times a fresh state was created | +| `golem_resources_created` | Counter | Number of internal resources created | +| `golem_resources_dropped` | Counter | Number of internal resources dropped | +| `golem_resources_active` | Gauge | Number of active internal resources | +| `golem_update_success_count` | Counter | Number of successful updates | +| `golem_update_failure_count` | Counter | Number of failed updates | +| `golem_transaction_committed` | Counter | Number of committed database transactions | +| `golem_transaction_rolled_back` | Counter | Number of rolled back database transactions | +| `golem_snapshot_size_bytes` | Counter | Snapshot size in bytes | +| `golem_oplog_processor_lag` | Gauge | Oplog processor delivery lag | + +Each metric includes `service.name`, `golem.agent.id`, `golem.component.id`, and `golem.component.version` attributes. + +## Local Observability Stack + +The Golem repository includes a ready-made Docker Compose setup at `docker-examples/otlp-collector/`: + +```shell +docker compose -f docker-examples/otlp-collector/docker-compose.yml up -d +``` + +This starts: +- **OTel Collector** on port 4318 (OTLP/HTTP) +- **Jaeger** on http://localhost:16686 (traces) +- **Prometheus** on http://localhost:9090 (metrics) +- **Loki** via Grafana (logs) +- **Grafana** on http://localhost:3000 (admin/admin) + +Configure the plugin with `endpoint: "http://localhost:4318"` to use this stack. + +## Per-Environment Configuration + +Use presets to vary the endpoint across environments: + +```yaml +components: + my-app:service: + plugins: + - name: golem-otlp-exporter + version: "1.5.0" + parameters: + endpoint: "http://localhost:4318" + signals: "traces,logs,metrics" + presets: + production: + pluginsMergeMode: replace + plugins: + - name: golem-otlp-exporter + version: "1.5.0" + parameters: + endpoint: "https://otel.prod.example.com:4318" + headers: "x-api-key={{ OTLP_API_KEY }}" + signals: "traces,logs,metrics" +``` + +Parameter values support Jinja-style `{{ VAR_NAME }}` substitution resolved against the host machine's environment variables at deploy time. + +## Key Points + +- **Built-in** — no `golem plugin register` needed, just add to `golem.yaml`. +- **Deploy required** — run `golem deploy` after adding the plugin configuration. +- Trace context propagates automatically through HTTP routes and RPC calls. +- **Custom spans are not available from the Go SDK yet** — Go agents get automatic spans (invocation, RPC, outgoing HTTP) only. +- Plugin can be activated/deactivated per agent with `golem agent activate-plugin` / `golem agent deactivate-plugin`. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-logging-go` | Structured logging from Go agent code (forwarded when `logs` is enabled) | +| `golem-manage-plugins` | General plugin installation model (manifest sections, CLI, priority, per-environment config) | diff --git a/golem-skills/skills/go/golem-file-io-go/SKILL.md b/golem-skills/skills/go/golem-file-io-go/SKILL.md new file mode 100644 index 0000000000..9dd6fb4584 --- /dev/null +++ b/golem-skills/skills/go/golem-file-io-go/SKILL.md @@ -0,0 +1,165 @@ +--- +name: golem-file-io-go +description: "Reading and writing files from a Go Golem agent with the standard os/io packages. Use when the user asks to read files, write files, or do filesystem operations from Go agent code." +--- + +# File I/O in a Go Agent + +## Overview + +There is **no** Golem-specific filesystem API in the Go SDK — you use the Go standard library. Golem agents run on a WASI filesystem, and the standard `os` and `io` packages work against it out of the box (the same runtime that exposes `os.Getenv`/`os.Environ` also serves file operations). So read and write files with `os.ReadFile`, `os.WriteFile`, `os.Open`, `os.OpenFile`, etc., exactly as in ordinary Go. + +To provision files *into* an agent's filesystem at startup, declare them in the `files:` section of `golem.yaml` — load `golem-add-initial-files` for that. + +## Steps + +1. **Import** `os` (and `io`/`bufio` as needed) in your agent's `impl` package. +2. **Read** provisioned files with `os.ReadFile` / write with `os.WriteFile`. +3. **Provision** any initial files via the `files:` block in `golem.yaml` (see `golem-add-initial-files`). + +## Reading Files + +```go +import "os" + +// Text (or any) file → []byte +data, err := os.ReadFile("/data/config.json") +if err != nil { + // handle: with golem.Must this would abort+retry the invocation +} +text := string(data) +``` + +## Writing Files + +Only paths that are writable — files provisioned `read-write`, or paths not provisioned at all (e.g. `/tmp`) — can be written to. + +```go +import "os" + +err := os.WriteFile("/tmp/output.txt", []byte("Hello, world!"), 0o644) +``` + +### Appending + +```go +import "os" + +f, err := os.OpenFile("/tmp/agent.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644) +if err != nil { /* handle */ } +defer f.Close() +_, _ = f.WriteString("log line\n") +``` + +## Checking Existence and Listing + +```go +import ( + "errors" + "os" +) + +if _, err := os.Stat("/data/config.json"); errors.Is(err, os.ErrNotExist) { + // not present +} + +entries, err := os.ReadDir("/data") +for _, e := range entries { + _ = e.Name() +} +``` + +## Complete Agent Example + +Definition (`agents/reader/reader.go`): + +```go +// Package reader is the DEFINITION of a file-reading agent. +package reader + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +type LogIn struct{ Message string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ReaderAgent", Description: "Reads a provisioned file and appends to a log", +}) + +var ( + Greeting = golem.DefineMethod[ID, golem.Unit, string]("greeting", golem.Desc("Read /data/greeting.txt")) + Log = golem.DefineMethod[ID, LogIn, golem.Unit]("log", golem.Desc("Append a line to /tmp/agent.log")) +) +``` + +Implementation (`agents/reader/impl/impl.go`): + +```go +// Package impl is the IMPLEMENTATION of the file-reading agent. +package impl + +import ( + "os" + "strings" + + "myapp/agents/reader" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(reader.Agent, func(reader.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, reader.Greeting, func(_ *golem.Context[state], _ golem.Unit) string { + // golem.Must aborts the invocation if the read fails. + data := golem.Must(os.ReadFile("/data/greeting.txt")) + return strings.TrimSpace(string(data)) + }) + + golem.Handle(agent, reader.Log, func(_ *golem.Context[state], in reader.LogIn) golem.Unit { + f := golem.Must(os.OpenFile("/tmp/agent.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)) + defer f.Close() + golem.Must(f.WriteString(in.Message + "\n")) + return golem.Unit{} + }) +} +``` + +`golem.Must` unwraps `(value, error)` and aborts the invocation (which then retries) on error — the fail-loud way to handle I/O errors when the caller should not observe them as a value. + +## Provisioning Initial Files (`golem.yaml`) + +Files are declared in the `files:` block and uploaded during deploy. Each entry has a `sourcePath`, an absolute `targetPath`, and optional `permissions`: + +```yaml +agents: + ReaderAgent: + files: + - sourcePath: ./data/greeting.txt + targetPath: /data/greeting.txt + permissions: read-only # default; cannot be written to + - sourcePath: ./data/scratch/ + targetPath: /var/scratch/ + permissions: read-write +``` + +See `golem-add-initial-files` for the full cascade (component / agent / preset levels), directory and remote sources, and merge modes. + +## Key Constraints + +- Use the **standard library** (`os`, `io`, `bufio`) — there is no SDK file API, and none is needed. The WASI filesystem backs it. +- Files provisioned with `read-only` (the default) **cannot be written**; write to `read-write` paths or unprovisioned paths like `/tmp`. +- `targetPath` values are **absolute** and unique across file entries. +- The filesystem is **per-agent-instance** and isolated; each instance has its own view. +- Initial files are declared at the **agent type** level in `golem.yaml`, not passed per instance at creation time. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-initial-files` | Provision files into the agent filesystem via `golem.yaml` | +| `golem-add-agent-go` | Define the agent that does the file I/O | +| `golem-add-config-go` | Prefer typed config over files for structured settings | diff --git a/golem-skills/skills/go/golem-fire-and-forget-go/SKILL.md b/golem-skills/skills/go/golem-fire-and-forget-go/SKILL.md new file mode 100644 index 0000000000..bb24289a35 --- /dev/null +++ b/golem-skills/skills/go/golem-fire-and-forget-go/SKILL.md @@ -0,0 +1,67 @@ +--- +name: golem-fire-and-forget-go +description: "Fire-and-forget agent invocations in Go with Trigger. Use when the user wants to enqueue work without awaiting a result, send a notification to another agent, fan out to many agents, or kick off background work in a Go Golem project." +--- + +# Fire-and-Forget Invocations in Go (`Trigger`) + +## Overview + +`Method.Trigger(client, in)` enqueues an invocation **without waiting for its result** and returns an `InvocationID`. Use it for notifications, fan-out, or handing work to a background/worker agent. Unlike a synchronous `Call`, `Trigger` does not block — so it is also safe for an agent to message **itself** (a synchronous self-`Call` would deadlock, since one instance handles one invocation at a time). + +## Steps + +1. **Import the target agent's definition package.** +2. **Get a client** with `Agent.Get(id)`. +3. **Trigger the method**: `Target.Method.Trigger(client, in)` — returns immediately. + +## Example + +```go +package impl + +import ( + "myapp/agents/coordinator" + "myapp/agents/worker" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(coordinator.Agent, func(coordinator.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, coordinator.Start, func(_ *golem.Context[state], in coordinator.StartIn) golem.Unit { + // Hand each unit of work to a worker without awaiting the outcome. + for _, w := range in.Jobs { + c := worker.Agent.Get(worker.ID{Name: w.Worker}) + worker.Dispatch.Trigger(c, worker.DispatchIn{Job: w.Job}) + } + return golem.Unit{} + }) +} +``` + +Fanning out is just a loop of `Trigger` calls — each runs independently on its target agent. + +## Trigger vs Call + +- `Call(c, in) Out` — blocks, returns the result. Use when you need the value. Never self-`Call`. +- `Trigger(c, in) InvocationID` — returns immediately, no result. Use for notifications, fan-out, and self-messaging. +- `CallAsync(c, in) *Future[Out]` — start now, await later with `Get()`. Use when you want the result but not to block yet (see `golem-call-another-agent-go`). + +The returned `InvocationID` is an opaque handle to the enqueued invocation; you can ignore it for pure fire-and-forget. + +## Key Constraints + +- `Trigger` delivers a value-less enqueue: there is no way to read a return value from it. If you need the result, use `Call`/`CallAsync`. +- As with all RPC, `Trigger` is called on the **method descriptor** (`Worker.Dispatch.Trigger(client, in)`), and the client comes from the callee's **definition** (`worker.Agent.Get(id)`). + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-call-another-agent-go` | You need the callee's result (sync `Call` / async `CallAsync`) | +| `golem-recurring-task-go` | Schedule a future/self invocation at a specific time | +| `golem-add-agent-go` | Define the agent being triggered | diff --git a/golem-skills/skills/go/golem-http-params-go/SKILL.md b/golem-skills/skills/go/golem-http-params-go/SKILL.md new file mode 100644 index 0000000000..29cfcedf6c --- /dev/null +++ b/golem-skills/skills/go/golem-http-params-go/SKILL.md @@ -0,0 +1,164 @@ +--- +name: golem-http-params-go +description: "Mapping HTTP request elements to Go agent method inputs. Use when the user asks about path variables, query parameters, header mapping, request body mapping, supported parameter types, or response mapping for HTTP endpoints in a Go Golem project." +--- + +# HTTP Request and Response Parameter Mapping (Go) + +## Overview + +When a Go agent is exposed over HTTP (see `golem-add-http-endpoint-go`), the platform maps parts of each request onto the agent's constructor (`ID`) fields and the method's **input struct** fields. This skill covers how path segments, query parameters, headers, and the request body bind to those fields, which Go types each binding accepts, and how return types map to HTTP responses. + +Binding is **metadata only** and declared on the definition: the mount `Path` on `Spec.HTTP` and the `golem.HTTP(...)` option on each method. There is no incoming-request handler in the guest. + +## Steps + +1. **Name fields to match wire names.** A path/query/header variable refers to an input field by its **lower-first** name: Go field `Sku` is `sku` on the wire, `MaxResults` is `maxResults`. +2. **Bind path variables** by putting `{name}` in the mount path (binds `ID` fields) or an endpoint path suffix (binds method input fields). +3. **Bind query and header values** inline (`?name={field}`) or with `golem.Query` / `golem.Header`. +4. **Leave body fields unbound** on body-carrying verbs; they arrive as JSON. + +## Path variables + +`{var}` segments bind by (lower-first) field name. + +- **Mount path** `{var}`s bind the agent's constructor (`ID`) fields. **Every `ID` field must appear as a `{var}`** so a request selects one instance. +- **Endpoint path** `{var}`s bind the method's input fields. + +```go +type ID struct{ Name string } // bound by {name} in the mount + +type LookupIn struct { + Sku string + Detailed bool +} + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "CatalogAgent", + HTTP: &golem.Mount{Path: "/catalog/{name}"}, // {name} → ID.Name +}) + +// GET /catalog/{name}/items/{sku} — {sku} → LookupIn.Sku +var Lookup = golem.DefineMethod[ID, LookupIn, ItemInfo]("lookup", + golem.HTTP(golem.GET("/items/{sku}", golem.Query("detailed", "detailed")))) +``` + +The trailing catch-all `{*rest}` captures everything after a prefix and may only appear as the **last** endpoint segment; it is **not** allowed in a mount path. + +## Query parameters + +Two equivalent forms. Inline `?name={field}` in the path suffix, or `golem.Query(wire, field)` when the wire name differs from the field: + +```go +type SearchIn struct { + Query string + MaxResults uint64 +} + +// GET /catalog/{name}/search?q=hello&limit=10 +var Search = golem.DefineMethod[ID, SearchIn, []Result]("search", + golem.HTTP(golem.GET("/search", + golem.Query("q", "query"), // ?q= → SearchIn.Query + golem.Query("limit", "maxResults"), // ?limit= → SearchIn.MaxResults + ))) +``` + +Inline `golem.GET("/search?q={query}&limit={maxResults}")` is equivalent when the parameter name matches the field's wire name. + +## Header variables + +`golem.Header(wire, field)` maps a request header to an input field: + +```go +type DataIn struct { + RequestID string + Token string +} + +var GetData = golem.DefineMethod[ID, DataIn, Data]("getData", + golem.HTTP(golem.GET("/data", + golem.Header("X-Request-Id", "requestId"), + golem.Header("Authorization", "token"), + ))) +``` + +Header names are matched case-insensitively; binding the same header twice on one endpoint is a definition error. + +## Supported types for path, query, and header bindings + +A value bound from a URL path/query/header string must decode into a **scalar** Go field. Only these kinds bind: + +| Go type | Bound from | +|---|---| +| `string` | used as-is | +| `bool` | `"true"` / `"false"` | +| `int8`, `int16`, `int32`, `int64` | signed integer | +| `uint8`, `uint16`, `uint32`, `uint64` | unsigned integer | +| `float32`, `float64` | floating-point number | + +Binding a non-scalar field (struct, slice, map) from path/query/header is a definition error: *"cannot bind input field … only scalar fields decode from a URL"*. Such fields must arrive in the body instead. + +> Prefer sized integers throughout. Bare `int`/`uint` are rejected at the agent-schema level because their width is platform-dependent (see `golem-add-agent-go`). + +## Request body mapping + +For body-carrying verbs (`POST`, `PUT`, `DELETE`, `PATCH`, …), any input field **not** bound to a path/query/header binding is populated from the JSON request body: + +```go +type UpdateIn struct { + Sku string // from the path + Name string // from the body + Count uint64 // from the body +} + +// POST /catalog/{name}/items/{sku} Body: {"name":"Widget","count":5} +var Update = golem.DefineMethod[ID, UpdateIn, Item]("update", + golem.HTTP(golem.POST("/items/{sku}"))) +``` + +Each unbound field becomes a top-level key in the JSON body object (field names lower-first / camelCase, as elsewhere in the SDK). + +`GET` and `HEAD` are **bodyless**: they carry no request body, so they must bind **every** input field from path/query/header. An unbound field on a bodyless verb is a definition error. + +## Return type to HTTP response mapping + +Handlers return their output value; the platform maps it to a response. In Go: + +| Return type | HTTP status | Body | +|---|---|---| +| `golem.Unit` | 204 No Content | empty | +| `T` (any type) | 200 OK | JSON-serialized `T` | +| `*T` | 200 OK if non-nil, 404 Not Found if nil | JSON `T` or empty | +| `golem.Result[T, E]` | 200 OK on `Ok`, 500 Internal Server Error on `Err` | JSON `T` or JSON `E` | + +`golem.Unit` is the empty result placeholder; `*T` is Golem's `option` (a nil pointer means "absent"); `golem.Result[Ok, Err]` returns the error as an observable value (see `golem-add-agent-go` on returning failures). + +## Data type to JSON mapping + +| Go type | JSON | +|---|---| +| `string` | string | +| sized ints / uints | number (integer) | +| `float32`, `float64` | number | +| `bool` | boolean | +| `[]T` | array | +| struct | object (lower-first / camelCase field names) | +| `*T` | value or `null` | +| `map[K]V` | object / WIT map | + +## Key Constraints + +- A variable can bind an input field from **exactly one** of path/query/header — binding it more than once is a definition error. +- Bindable path/query/header fields must be scalar; non-scalars go in the body. +- Bodyless verbs (`GET`, `HEAD`) must bind every input field. +- Field references on the wire use the **lower-first** field name (`Sku` → `sku`). +- **Go gap:** the Rust SDK's `UnstructuredBinary` / `UnstructuredText` (with `AllowedMimeTypes` / `AllowedLanguages`) raw-body wrapper types have **no public Go equivalent** yet — model bodies as JSON structs, or use `[]byte` fields for raw bytes. + +### Related Skills + +| Skill | When to Load | +|---|---| +| `golem-add-http-endpoint-go` | The high-level workflow of mounting an agent and adding routes | +| `golem-add-http-auth-go` | Require authentication on endpoints | +| `golem-add-cors-go` | Allow cross-origin requests | +| `golem-add-agent-go` | Define the agent and its input/output types | diff --git a/golem-skills/skills/go/golem-interactive-repl-go/SKILL.md b/golem-skills/skills/go/golem-interactive-repl-go/SKILL.md new file mode 100644 index 0000000000..d752d86de4 --- /dev/null +++ b/golem-skills/skills/go/golem-interactive-repl-go/SKILL.md @@ -0,0 +1,85 @@ +--- +name: golem-interactive-repl-go +description: "Using the Golem REPL for interactive testing and scripting of agents. Use when asked to test agents interactively, run a REPL, or execute test scripts against deployed agents." +--- + +# Golem Interactive REPL (Go) + +The `golem repl` command starts an interactive REPL for testing and scripting agents. It supports both an **interactive mode** and a **script execution mode**. + +**There is no Go REPL language** in Golem. Use the **TypeScript REPL** (the default) to interact with your Go agents — all agent types are available as TypeScript classes regardless of the agent's source language. + +## Interactive Mode + +```shell +golem repl +``` + +Starts a TypeScript REPL with all agent client classes preconfigured in the global scope — including your Go agents. You can get or create agent instances, invoke methods, and see logs streamed during invocations, all with full type safety. + +### Example: Invoking a Go counter agent from the TypeScript REPL + +A Go `CounterAgent` whose `ID` is `struct{ Name string }` is addressed by that name, and its `increment` / `add` / `value` methods are exposed as camelCase client methods: + +```typescript +const c1 = await CounterAgent.get("c1") +await c1.increment() +await c1.add(5) +const value = await c1.value() +``` + +### Built-in Commands + +The REPL provides built-in commands that mirror CLI functionality. Commands accept both `.` and `:` prefixes: + +- `.build` / `:build` — build the project +- `.deploy` / `:deploy` — deploy components +- `.help` / `:help` — show available commands + +This lets you build, deploy, and test agents without leaving the REPL. + +## Script Mode + +Run a TypeScript file non-interactively: + +```shell +golem repl --script-file test.ts --yes +``` + +The `--yes` flag auto-confirms any prompts. The script has the same global scope as the interactive REPL — all agent client classes are available, including Go agents. + +Run the script after creating it, unless the user explicitly asked not to. + +### Example script (`test.ts`) + +```typescript +const c2 = await CounterAgent.get("c2") +await c2.increment() +await c2.increment() +``` + +Run it: + +```shell +golem repl --script-file test.ts --yes +``` + +## Available REPL Languages + +| Language | Flag | Interactive | Script | Notes | +|----------|------|-------------|--------|-------| +| TypeScript | (default) | ✅ | ✅ | Recommended — works with all agent languages | + +No Go REPL is available. The TypeScript REPL is recommended for interacting with Go agents. + +## Prerequisites + +- The Golem server must be running (`golem server run`) +- Components must be deployed (`golem deploy`) + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-invoke-agent-go` | Invoke an agent method from the CLI (non-REPL) | +| `golem-add-agent-go` | Define the agent you're testing | diff --git a/golem-skills/skills/go/golem-invoke-agent-go/SKILL.md b/golem-skills/skills/go/golem-invoke-agent-go/SKILL.md new file mode 100644 index 0000000000..9c9fd7e3e0 --- /dev/null +++ b/golem-skills/skills/go/golem-invoke-agent-go/SKILL.md @@ -0,0 +1,118 @@ +--- +name: golem-invoke-agent-go +description: "Invoking a Go Golem agent method from the CLI and waiting for its result. Use when the user asks to call, invoke, or run a method on a deployed agent in a Go Golem project." +--- + +# Invoking a Go Golem Agent with `golem agent invoke` + +## Overview + +`golem agent invoke` calls a method on a deployed agent and **waits for the result**. The agent is created automatically on first invocation if it does not exist yet. Standard output, error, and log streams from the agent are streamed live to the terminal by default. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Pick the method** to call (the WIT name, e.g. `increment`, `add`, `value`). +3. **Run `golem agent invoke`** with the agent ID, method name, and any arguments. +4. **Read the result** — text by default, or `--format json` / `--format yaml` for machine output. + +## Usage + +```shell +golem agent invoke [ARGUMENTS...] +``` + +## Agent ID Format + +The agent ID identifies the agent type and its constructor parameters: + +``` +AgentTypeName(param1, param2, ...) +``` + +For a Go agent, the constructor parameters are the fields of its `ID` struct in declaration order. `CounterAgent`'s `ID` is `struct{ Name string }`, so its ID is `CounterAgent("my-counter")`. For an agent whose `ID` has no fields (a singleton), use empty parentheses: `AgentTypeName()`. + +The agent ID can optionally be prefixed with environment or application paths: + +| Format | Description | +|--------|-------------| +| `AgentTypeName(params)` | Standalone agent name | +| `env/AgentTypeName(params)` | Environment-specific | +| `app/env/AgentTypeName(params)` | Application and environment-specific | +| `account/app/env/AgentTypeName(params)` | Account, application, and environment-specific | + +## Examples + +### Invoke a method with no parameters + +```shell +golem agent invoke 'CounterAgent("my-counter")' increment +``` + +### Invoke a method with an argument + +`add` takes one parameter (the `By` field of `AddIn`), passed positionally: + +```shell +golem agent invoke 'CounterAgent("my-counter")' add 5 +``` + +### Read the current value + +```shell +golem agent invoke 'CounterAgent("my-counter")' value +``` + +### Invoke in a specific environment + +```shell +golem agent invoke 'staging/CounterAgent("my-counter")' value +``` + +### Invoke with an explicit idempotency key + +```shell +golem agent invoke -i my-unique-key 'CounterAgent("my-counter")' increment +``` + +## Output + +Text output renders return values in a WIT value syntax. Methods returning `golem.Unit` or no value print `void` in text mode. + +For machine-readable output, use `--format json` or `--format yaml`. A single return value includes `result` plus `resultJson`; multiple return values include `result` plus `resultsJson`; methods returning no value omit result fields. + +## Available Options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | Only trigger the invocation without waiting for the result (fire-and-forget) | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | +| `--schedule-at ` | Schedule the invocation at a specific time (requires `--trigger`; ISO 8601 format) | + +## Value Syntax + +Agent ID parameters and method arguments use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Results: `ok(value)` / `err(value)`. +- Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- `golem agent invoke` **blocks** until the agent returns; use `--trigger` for fire-and-forget. +- Every invocation uses an idempotency key (auto-generated if not supplied), guaranteeing at-most-once execution even if the CLI retries. +- If the component is not deployed yet and the CLI runs from an application directory, the command auto-builds and deploys it before invoking. +- The agent ID's constructor arguments must match the fields of the Go `ID` struct in order. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-trigger-agent-go` | Fire-and-forget invocation from the CLI (`--trigger`) | +| `golem-schedule-agent-go` | Schedule a future invocation from the CLI | +| `golem-create-agent-instance-go` | Pre-create an agent instance (`golem agent new`) | +| `golem-add-agent-go` | Define the agent and its methods | diff --git a/golem-skills/skills/go/golem-logging-go/SKILL.md b/golem-skills/skills/go/golem-logging-go/SKILL.md new file mode 100644 index 0000000000..16c80674b2 --- /dev/null +++ b/golem-skills/skills/go/golem-logging-go/SKILL.md @@ -0,0 +1,126 @@ +--- +name: golem-logging-go +description: "Structured logging from a Go Golem agent via log/slog. Use when the user asks about logging, log levels, structured/key-value logs, or printing debug/info/error output from a Go agent." +--- + +# Logging from a Go Agent + +## Overview + +Golem routes Go logging through the host's structured logging channel (`wasi:logging`), so each record carries a typed **level** and a **context** (category) string and shows up in worker logs and the oplog with the right severity. Unlike writing to stdout/stderr — which the host records as raw bytes with no level — this gives you filterable, leveled logs. + +The runtime installs the SDK's handler as the **default `log/slog` handler on agent startup**, so ordinary standard-library structured logging just works with **no setup code**. You only reach for the SDK's `log` package (`github.com/golemcloud/golem/sdks/go/golem/log`) when you want to customize the level or category, or build a handler yourself. + +## Steps + +1. **Log with the standard library** — call `slog.Info`, `slog.Warn`, etc. Nothing to import beyond `log/slog`. +2. **(Optional) Customize** the minimum level or base category with `log.SetDefault(...)` from the SDK's `log` package. +3. **View logs** with `golem agent stream` or during `golem agent invoke`. + +## Quick Start (no setup) + +The runtime already installed the host-logging handler as slog's default, so just use `log/slog`: + +```go +import "log/slog" + +slog.Info("order created", "orderID", orderID, "total", total) // -> level=info +slog.Warn("retrying", "attempt", attempt, "reqID", reqID) // -> level=warn +slog.Error("db connect failed", "err", err) // -> level=error +slog.Debug("processing item", "id", item.ID) // -> level=debug +``` + +Structured context is passed as trailing key/value pairs (slog attributes) and is rendered into the log record. `slog.With(...)` returns a logger that prepends attributes to every record: + +```go +logger := slog.With("area", "billing") +logger.Error("declined", "code", code) +``` + +Because `slog.SetDefault` also bridges Go's standard `log` package, plain `log.Print` / `log.Printf` output flows through the same channel too (as `info`-level records). + +## Log Levels + +Records map onto the `wasi:logging` severities. slog's built-in levels cover debug/info/warn/error; the SDK also defines trace and critical (`sdks/go/golem/log/log.go:47`): + +| slog call | Level | Use for | +|-----------|-------|---------| +| `slog.Log(ctx, level-4, ...)` (below Debug) | `trace` | Fine-grained control flow | +| `slog.Debug` | `debug` | Debugging information | +| `slog.Info` | `info` | Normal operations, monitoring | +| `slog.Warn` | `warn` | Degraded behavior, hazards | +| `slog.Error` | `error` | Serious errors | +| `slog.Log` a full step above Error | `critical` | Fatal conditions | + +The SDK exposes the raw severities as `log.Trace`, `log.Debug`, `log.Info`, `log.Warn`, `log.Error`, `log.Critical` (type `log.Level`) for the low-level `log.Log` helper. + +## Customizing the default logger + +Import the SDK's `log` package (alias it to avoid clashing with the standard `log`) and call `log.SetDefault` to change the minimum level or the base category. `Options` has just `Level` (an `slog.Leveler`) and `Context` (the base category string) — see `sdks/go/golem/log/log.go:103`. + +```go +import ( + "log/slog" + + golemlog "github.com/golemcloud/golem/sdks/go/golem/log" +) + +func init() { + // Emit debug-and-up, tagging every record with the "billing" category. + golemlog.SetDefault(&golemlog.Options{ + Level: slog.LevelDebug, + Context: "billing", + }) +} +``` + +## Building a handler yourself + +`log.NewHandler(opts)` returns an `*slog.Handler` you can pass to `slog.New` (for a scoped logger, or to compose): + +```go +handler := golemlog.NewHandler(&golemlog.Options{Context: "worker"}) +logger := slog.New(handler) +logger.Info("started") +``` + +slog groups map onto the category: `logger.WithGroup("retry")` extends the context to read like `worker/retry` rather than key-prefixing attributes. + +## Lower-level helpers + +- `log.Log(level, context, message)` — emit one raw record directly (`sdks/go/golem/log/log.go:58`). +- `log.Writer(level, context)` — an `io.Writer` where each write becomes one record at that level/category, handy for wiring a sink that expects an `io.Writer`. + +```go +golemlog.Log(golemlog.Warn, "startup", "cache warm skipped") +``` + +## Viewing Logs + +Stream live agent output (stdout, stderr, and the log channel): + +```shell +golem agent stream '' +``` + +Logs also stream automatically during an invocation: + +```shell +golem agent invoke '' '' [args] +# use --no-stream to suppress +``` + +## Key Constraints + +- **No initialization needed** — the runtime installs the host-logging handler as slog's default on startup; just use `log/slog`. +- Prefer `slog.*` over `fmt.Println`/stdout: stdout/stderr are captured as raw bytes with no level or category. +- Logging is a **side effect**: during replay (crash recovery) log calls from replayed operations are skipped — only new invocations produce log output. +- The SDK's package is named `log`, which collides with the standard library `log`; import it under an alias (e.g. `golemlog`). +- `int`/`uint`-width and other value formatting follow slog's attribute rendering (values are resolved and stringified into the message). + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-enable-otlp-go` | Forward logs (and traces/metrics) to an OTLP collector | +| `golem-add-agent-go` | Define the agent whose handlers emit these logs | diff --git a/golem-skills/skills/go/golem-make-http-request-go/SKILL.md b/golem-skills/skills/go/golem-make-http-request-go/SKILL.md new file mode 100644 index 0000000000..33fc769c5f --- /dev/null +++ b/golem-skills/skills/go/golem-make-http-request-go/SKILL.md @@ -0,0 +1,77 @@ +--- +name: golem-make-http-request-go +description: "Making outgoing HTTP requests from a Go agent. Use when the user wants an agent to call an external API/service, fetch a URL, or make an outbound HTTP/HTTPS request in a Go Golem project." +--- + +# Outgoing HTTP Requests from a Go Agent + +## Overview + +Use the **standard library `net/http`** package directly. The SDK routes `net/http` through Golem's durable `wasi:http` transport, so each request is recorded in the oplog and **served from it on replay** after a restart rather than re-issued — outbound calls are effectively exactly-once across crashes/restarts. No manual wiring or custom transport is needed. + +## Steps + +1. **Import `net/http`** (and `io` to read the body). +2. **Make the request** — `http.Get(url)`, or build an `*http.Request` and use `http.DefaultClient.Do`. +3. **Read the response body**, then `Close` it. +4. Let failures propagate (panic) — Golem retries transparently; do **not** add manual retry loops. + +## Example + +```go +package impl + +import ( + "io" + "net/http" + "os" + + "myapp/agents/fetcher" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(fetcher.Agent, func(fetcher.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, fetcher.Fetch, func(_ *golem.Context[state], in fetcher.FetchIn) string { + url := "https://api.example.com/thing?q=" + in.Query + // golem.Must panics on error (the SDK turns the panic into an agent-error + // and retries per policy). Use it for calls that shouldn't fail normally. + resp := golem.Must(http.Get(url)) + defer resp.Body.Close() + return string(golem.Must(io.ReadAll(resp.Body))) + }) +} +``` + +`golem.Must(v, err)` returns `v` or panics on `err` — the fail-loud idiom for operations Golem should retry. To surface an HTTP failure to the caller as a *value* instead, return a `golem.Result` and inspect the error yourself (see `golem-add-agent-go` → Returning Failures). + +## POST / custom requests + +```go +req := golem.Must(http.NewRequest("POST", url, strings.NewReader(body))) +req.Header.Set("Content-Type", "application/json") +resp := golem.Must(http.DefaultClient.Do(req)) +defer resp.Body.Close() +``` + +## Durability & retries + +- The HTTP call is a durable operation: on replay the recorded response is returned, so the external service is **not** hit again. +- **Do not** write manual retry/backoff loops — Golem retries failed operations automatically (a default policy applies; customize with the retry-policy helpers only when the *strategy* must change). + +## Key Constraints + +- Target is **WASM**: there are no raw sockets. `net.Dial`, most database drivers, and custom transports won't work — outgoing traffic goes through the SDK's WASI-backed `net/http` transport. +- **Async handles cannot outlive an invocation**: read/consume the response within the same handler; don't stash an unresolved response/body in agent state to use later. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-http-endpoint-go` | Expose *this* agent over HTTP (incoming requests) | +| `golem-call-another-agent-go` | Call another Golem agent instead of an external HTTP service | +| `golem-add-agent-go` | Define the agent making the request | diff --git a/golem-skills/skills/go/golem-mark-read-only-go/SKILL.md b/golem-skills/skills/go/golem-mark-read-only-go/SKILL.md new file mode 100644 index 0000000000..6e3fa88278 --- /dev/null +++ b/golem-skills/skills/go/golem-mark-read-only-go/SKILL.md @@ -0,0 +1,158 @@ +--- +name: golem-mark-read-only-go +description: "Marking Go agent methods as read-only for a side-effect-free guarantee and result caching. Use when the user wants a cacheable query method, a method that must not do remote side effects, or HTTP GET endpoints backed by a read-only method in a Go Golem project." +--- + +# Marking Agent Methods as Read-Only (Go) + +## Overview + +A **read-only** method is one you promise is a pure read of the agent's +already-loaded state. Golem enforces the most important part of the contract: the +runtime **traps outgoing HTTP and agent RPC** from a read-only method. In +exchange, Golem **caches the result** per the chosen cache policy. + +You mark a method read-only by passing the `golem.ReadOnly(...)` option to +`golem.DefineMethod` in the **definition** package — it is a `golem.MethodOpt`, +just like `golem.Desc(...)` and `golem.HTTP(...)`. + +## Steps + +1. **Add `golem.ReadOnly()`** as an option on the method descriptor in the def package. +2. **(Optional) choose a cache policy** — pass `golem.NoCache()`, `golem.CacheUntilWrite()`, or `golem.CacheFor(ttl)`. +3. **Keep the handler pure** — no outgoing HTTP, no RPC, no mutation of durable state. +4. **Build** — run `golem build`. + +## Usage + +```go +// Package counter is the DEFINITION. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{Name: "CounterAgent"}) + +var ( + // Read-write: mutates shared state. + Increment = golem.DefineMethod[ID, golem.Unit, int64]("increment") + + // Read-only: pure read over already-loaded state (default cache policy). + Value = golem.DefineMethod[ID, golem.Unit, int64]("value", golem.ReadOnly()) +) +``` + +The implementation is unchanged — a read-only method is an ordinary handler that +happens not to perform side effects: + +```go +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.count++ + return ctx.State.count + }) + golem.Handle(agent, counter.Value, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.count // pure read + }) +} +``` + +## Cache Policy + +Pass at most one `golem.CachePolicy` to `golem.ReadOnly(...)`. The default (no +argument) is `CacheUntilWrite`. + +| Policy | Call | Behavior | +|---|---|---| +| Until write (default) | `golem.ReadOnly()` or `golem.ReadOnly(golem.CacheUntilWrite())` | Cached until any mutating (non-read-only) method of the agent completes | +| TTL | `golem.ReadOnly(golem.CacheFor(30 * time.Second))` | Expires after the given duration even without a write | +| No cache | `golem.ReadOnly(golem.NoCache())` | Runs every time; still side-effect-free, never cached | + +```go +import "time" + +var ( + // Cached until the next write. + Catalog = golem.DefineMethod[ID, golem.Unit, Catalog]("catalog", golem.ReadOnly()) + + // Cached for a minute regardless of writes. + Rates = golem.DefineMethod[ID, golem.Unit, Rates]("rates", golem.ReadOnly(golem.CacheFor(time.Minute))) + + // Never cached, but still trapped against remote side effects. + Compute = golem.DefineMethod[ID, ComputeIn, int64]("compute", golem.ReadOnly(golem.NoCache())) +) +``` + +`golem.CacheFor` requires a **positive** ttl — `golem.CacheFor(0)` (or a negative +duration) is a definition error; use `golem.NoCache()` to disable caching. + +## What the Runtime Enforces (and what it doesn't) + +A read-only method must be a pure function of the agent's already-loaded state and +its inputs. + +| Allowed | Trapped by the runtime | Not checked — your responsibility | +|---|---|---| +| Reading `ctx.State` fields | Outgoing HTTP requests | Mutating `ctx.State` in memory | +| Computation over inputs | RPC calls to other agents | Reading the clock / current time | +| Returning derived values | | Randomness | +| | | Reading environment variables | + +- **Outgoing HTTP and agent RPC trap** with a read-only violation before they run. + A read-only method therefore cannot call another agent — do read-only RPC + fan-out from a regular method instead (see `golem-call-another-agent-go`). +- **In-memory mutation, clocks, randomness, and env reads are NOT detected.** They + do not trap, but they break the cache contract (a cached, stale, or + non-deterministic value). Keeping the method pure is up to you. If you need any + of them, use a regular (non-read-only) method. + +## Common Pitfalls + +- **Read-only on an `Ephemeral` agent is a definition error** — ephemeral agents + have no shared state to read. Remove `golem.ReadOnly()` or make the agent + durable (see `golem-configure-durability-go`). +- **Setting `golem.ReadOnly()` twice on one method is a definition error**, as is + passing **more than one** cache policy — both are reported at discovery. +- **`golem.NoCache()` does not relax the contract** — it only disables caching; + outgoing HTTP and RPC still trap and the same purity rules apply. + +## HTTP endpoints + +Read-only methods are the natural fit for HTTP `GET`/`HEAD` endpoints. Combine +`golem.ReadOnly(...)` with `golem.HTTP(golem.GET(...))` on the same method (see +`golem-add-http-endpoint-go`): + +```go +var Catalog = golem.DefineMethod[ID, golem.Unit, Catalog]("catalog", + golem.ReadOnly(), + golem.HTTP(golem.GET("/catalog"))) +``` + +## Not available in the Go SDK + +Unlike the Rust SDK, the Go SDK has **no per-principal read-only caching** — there +is no `Principal` parameter you can add to a method and no automatic +`Cache-Control: private` / `Vary` switch. Read-only results are cached +per `(method, input)` and shared across callers. If you need per-caller isolation, +model it explicitly (e.g. include the caller identity in the method input) rather +than expecting the runtime to derive it. + +## Key Constraints + +- `golem.ReadOnly(...)` is a per-method option in the **definition** package; an + agent freely mixes read-only and regular methods. +- Cache policy is only expressible via `golem.ReadOnly(...)`; a regular method + cannot carry one. +- Read-only is only valid on **Durable** agents. +- Pass **at most one** cache policy; the default is `golem.CacheUntilWrite()`. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-configure-durability-go` | Read-only requires a durable agent; configure durability/snapshots | +| `golem-add-http-endpoint-go` | Expose a read-only method as a cacheable GET/HEAD endpoint | +| `golem-call-another-agent-go` | Read-only methods cannot RPC; fan out from a regular method | +| `golem-add-agent-go` | Define the agent and its methods | diff --git a/golem-skills/skills/go/golem-multi-instance-agent-go/SKILL.md b/golem-skills/skills/go/golem-multi-instance-agent-go/SKILL.md new file mode 100644 index 0000000000..d0e8050ad0 --- /dev/null +++ b/golem-skills/skills/go/golem-multi-instance-agent-go/SKILL.md @@ -0,0 +1,77 @@ +--- +name: golem-multi-instance-agent-go +description: "Addressing multiple instances of a Go agent by identity. Use when the user wants many instances of an agent (one per user/tenant/session), a composite key/identity, or ephemeral/phantom instances in a Go Golem project." +--- + +# Multiple Instances of a Go Agent + +## Overview + +An agent *type* has many *instances*, each identified by its **`ID`** (the constructor parameters). `Agent.Get(id)` returns a client for the durable instance with that id — **two `Get`s with the same id address the same agent**, created implicitly on first invocation. For one-off/ephemeral work use `Agent.NewPhantom(id)`, which allocates a fresh, non-persistent instance. + +## Identity: single or composite + +The `ID` struct's fields are the identity — use several fields for a composite key: + +```go +package session + +import "github.com/golemcloud/golem/sdks/go/golem" + +// One session instance per (user, device). +type ID struct { + User string + Device string +} + +var Agent = golem.DefineAgent[ID](golem.Spec{Name: "SessionAgent", Description: "Per-user, per-device session"}) + +var Touch = golem.DefineMethod[ID, golem.Unit, int64]("touch", golem.Desc("Record activity, return hit count")) +``` + +## Addressing a specific instance + +```go +// Durable instance for this (user, device) — same id always maps to the same agent. +c := session.Agent.Get(session.ID{User: "alice", Device: "laptop"}) +hits := session.Touch.Call(c, golem.Unit{}) +``` + +Iterate ids to address many instances: + +```go +for _, u := range users { + c := session.Agent.Get(session.ID{User: u, Device: "web"}) + session.Touch.Trigger(c, golem.Unit{}) // fan out +} +``` + +## Ephemeral (phantom) instances + +`NewPhantom(id)` allocates a **fresh** instance with no durable identity — the right choice for throwaway/per-request work, and the only way to get a client for an ephemeral agent: + +```go +c := session.Agent.NewPhantom(session.ID{User: "alice", Device: "kiosk"}) +session.Touch.Call(c, golem.Unit{}) + +// To reach the SAME phantom again later, capture and reuse its id: +if pid, ok := c.PhantomID().Get(); ok { // PhantomID() is Option[UUID] + c2 := session.Agent.Get(session.ID{User: "alice", Device: "kiosk"}, + golem.WithPhantomID(pid)) // same phantom instance + _ = c2 +} +``` + +## Key Constraints + +- The `ID` fields *are* the identity: same values → same agent; different values → different agent. There is no separate "create" step. +- Instances are **durable by default**; use `NewPhantom` for ephemeral ones. A phantom's id lives only on its client — capture `Client.PhantomID()` if you need to re-address it. +- Over HTTP, each `ID` field must appear as a `{var}` in the mount path so a URL selects the instance (see `golem-add-http-endpoint-go`). + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Define the agent type and its `ID` | +| `golem-call-another-agent-go` | Call a specific instance from another agent | +| `golem-add-http-endpoint-go` | Select an instance from a request URL | diff --git a/golem-skills/skills/go/golem-parallel-workers-go/SKILL.md b/golem-skills/skills/go/golem-parallel-workers-go/SKILL.md new file mode 100644 index 0000000000..43825dbd67 --- /dev/null +++ b/golem-skills/skills/go/golem-parallel-workers-go/SKILL.md @@ -0,0 +1,157 @@ +--- +name: golem-parallel-workers-go +description: "Fan out work to multiple parallel agents and collect results in a Go Golem project. Use when the user asks about parallel execution, fan-out/fan-in, spawning worker agents for parallel work, or aggregating results from multiple agents in a Go Golem project." +--- + +# Parallel Workers — Fan-Out / Fan-In (Go) + +## Overview + +A single Golem agent processes invocations **sequentially** — it cannot run work in parallel by itself. To execute work concurrently, distribute it across **multiple agent instances** and have them run at the same time. The Go SDK gives you two building blocks: + +1. **`CallAsync` + `Future.Get`** — start several cross-agent calls at once, then await each. This is the SDK's only source of concurrency: `Call` (synchronous `invoke-and-await`) blocks the whole component, whereas `Future.Get` is async, so a goroutine blocked in it yields to the component-model event loop and lets the other in-flight calls proceed. +2. **`Trigger` + promises** — fire-and-forget each worker, hand each a promise ID, then await all the promises. Best for long-running work where you don't want a call in flight the whole time. + +> **Platform contract:** a single target instance handles one invocation at a time. Concurrency comes from fanning out to **different** target instances (distinct `ID`s), not from calling the same instance repeatedly. + +> **No `fork`:** the Rust SDK's `fork()` has no equivalent in the current Go SDK. Achieve parallelism by addressing multiple worker instances by `ID` as shown below. + +## Approach 1: async fan-out with `CallAsync` / `Future.Get` + +Start every worker call with `CallAsync`, collect the `*golem.Future[Out]` values in a slice, then `Get()` each. All calls are in flight while you await. + +### Worker definition (`agents/worker/worker.go`) + +```go +package worker + +import "github.com/golemcloud/golem/sdks/go/golem" + +// ID identifies a worker instance — distinct IDs run in parallel. +type ID struct{ Index int64 } + +type ProcessIn struct{ Item string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "WorkerAgent", + Description: "Processes one item", +}) + +var Process = golem.DefineMethod[ID, ProcessIn, string]("process", + golem.Desc("Process a single item and return the result")) +``` + +### Coordinator fan-out (`agents/coordinator/impl/impl.go`) + +```go +package impl + +import ( + "myapp/agents/coordinator" + "myapp/agents/worker" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(coordinator.Agent, func(coordinator.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, coordinator.FanOut, func(_ *golem.Context[state], in coordinator.FanOutIn) []string { + // 1. Start every call — each returns immediately with a future. + futures := make([]*golem.Future[string], len(in.Items)) + for i, item := range in.Items { + // A distinct worker instance per item → they run concurrently. + c := worker.Agent.Get(worker.ID{Index: int64(i)}) + futures[i] = worker.Process.CallAsync(c, worker.ProcessIn{Item: item}) + } + + // 2. Await each. All calls were already in flight, so this fans in. + results := make([]string, len(futures)) + for i, f := range futures { + results[i] = f.Get() // Get() blocks (and yields) for this one result + } + return results + }) +} +``` + +`Future.Get` is **fail-loud**: an infra failure (a `golem.RemoteCallError`) traps and surfaces as an agent-error. Model *expected* per-item outcomes as a `golem.Result` in the worker method's output instead, then unwrap or inspect each result: + +```go +// worker.Process returns golem.Result[string, string] +res := futures[i].Get() // golem.Result[string, string] +if res.IsErr() { + failures = append(failures, res.Err()) +} else { + successes = append(successes, res.Ok()) +} +``` + +## Approach 2: fire-and-forget with promise collection + +For long-running work, `Trigger` each worker (fire-and-forget, no call held open) and pass each a promise ID; the worker completes its promise when done, and the coordinator awaits them all. + +### Coordinator + +```go +golem.Handle(agent, coordinator.DispatchAndCollect, func(ctx *golem.Context[state], in coordinator.RegionsIn) []string { + // One promise per worker. + promises := make([]*golem.Promise[string], len(in.Regions)) + for i := range in.Regions { + promises[i] = golem.NewPromise[string]() + } + + // Fire-and-forget: hand each worker its region and its promise id. + for i, region := range in.Regions { + c := worker.Agent.Get(worker.ID{Region: region}) + worker.RunReport.Trigger(c, worker.RunReportIn{Promise: promises[i].ID()}) + } + + // Await all promises (each durably suspends until its worker completes it). + results := make([]string, len(promises)) + for i, p := range promises { + results[i] = p.Await() + } + return results +}) +``` + +### Worker completes its promise + +```go +golem.Handle(agent, worker.RunReport, func(ctx *golem.Context[state], in worker.RunReportIn) golem.Unit { + report := "Report for " + ctx.State.region + ": OK" + golem.CompletePromise(in.Promise, report) + return golem.Unit{} +}) +``` + +`Trigger` returns a `golem.InvocationID` and does not wait; a failure after the invocation is accepted is not reported at the trigger site — the worker signals completion (or failure) through its promise. + +## When to use which + +| Criteria | `CallAsync` / `Future` | `Trigger` + promises | +|----------|------------------------|----------------------| +| Short calls, want results inline | ✅ Best fit | Works but heavier | +| Long-running work, don't hold a call open | ⚠️ Call stays in flight | ✅ Best fit | +| Need the invocation identity for other work | `Future.ID` | `Trigger` returns `InvocationID` | +| Per-item error as a value | Return `golem.Result` in the method | Encode outcome in the promise payload | + +## Key Constraints + +- **No threads within an agent.** Parallelism comes from distributing across distinct worker instances (distinct `ID`s); fanning out to the *same* instance serializes. +- Don't hold a `*golem.Future` across invocations — start it and `Get()` it within the same handler. `Get` consumes the future (a second `Get` panics). +- `Future.Get` and `Promise.Await` are fail-loud; model expected outcomes as a `golem.Result` in the method output, not as a trap. +- Avoid a **synchronous** cycle: two agents each blocking in `Call` on the other deadlocks. Break cycles with `Trigger` / promises. +- Worker instances persist after the coordinator finishes (they are durable by default); give them stable IDs you can address again, or make them ephemeral (see `golem-stateless-agent-go`). + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-call-another-agent-go` | The synchronous / async call mechanics (`Call`, `CallAsync`) | +| `golem-fire-and-forget-go` | `Trigger` details for fire-and-forget dispatch | +| `golem-wait-for-external-input-go` | Promises used to collect worker results | +| `golem-multi-instance-agent-go` | Address many worker instances by `ID` (and phantoms) | diff --git a/golem-skills/skills/go/golem-recurring-task-go/SKILL.md b/golem-skills/skills/go/golem-recurring-task-go/SKILL.md new file mode 100644 index 0000000000..114504a580 --- /dev/null +++ b/golem-skills/skills/go/golem-recurring-task-go/SKILL.md @@ -0,0 +1,98 @@ +--- +name: golem-recurring-task-go +description: "Recurring / scheduled work in a Go agent. Use when the user wants a periodic task, a cron-like loop, a self-rescheduling agent, or to schedule a future invocation (of itself or another agent) in a Go Golem project." +--- + +# Recurring & Scheduled Tasks in Go + +## Overview + +A recurring task is a method that **reschedules itself**: it does its work, then schedules the next run. Scheduling uses `Method.Schedule(client, at, in)`, which arranges an invocation at a future time and returns a cancelable `*golem.ScheduledInvocation`. + +To message itself an agent needs a client for its **own** instance, which needs its own `ID`. `Context` only exposes the raw id string, so **capture the typed `ID` in state at construction** — the constructor passed to `golem.Implement` receives it. + +## Steps + +1. **Capture the agent's own `ID` in state** in the `Implement` constructor. +2. **Add a tick method** that does the work and then `Schedule`s itself for the next run. +3. **Start the loop** — a `Start` method (or an external trigger) schedules the first tick. + +## Example + +Definition (`agents/poller/poller.go`): + +```go +package poller + +import "github.com/golemcloud/golem/sdks/go/golem" + +type ID struct{ Name string } + +var Agent = golem.DefineAgent[ID](golem.Spec{Name: "PollerAgent", Description: "Periodic poller"}) + +var ( + Start = golem.DefineMethod[ID, golem.Unit, golem.Unit]("start", golem.Desc("Begin the recurring loop")) + Tick = golem.DefineMethod[ID, golem.Unit, golem.Unit]("tick", golem.Desc("One iteration; reschedules itself")) +) +``` + +Implementation (`agents/poller/impl/impl.go`): + +```go +package impl + +import ( + "time" + + "myapp/agents/poller" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +const interval = time.Minute + +// state stashes the agent's own ID so it can build a client to itself. +type state struct{ self poller.ID } + +// The constructor receives this instance's ID — capture it. +var agent = golem.Implement(poller.Agent, func(id poller.ID) *state { return &state{self: id} }) + +func init() { + golem.Handle(agent, poller.Start, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + self := poller.Agent.Get(ctx.State.self) + poller.Tick.Schedule(self, time.Now().Add(interval), golem.Unit{}) + return golem.Unit{} + }) + + golem.Handle(agent, poller.Tick, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + // ... do the periodic work ... + + // schedule the next iteration + self := poller.Agent.Get(ctx.State.self) + poller.Tick.Schedule(self, time.Now().Add(interval), golem.Unit{}) + return golem.Unit{} + }) +} +``` + +Kick off the loop by invoking `start` once (from the CLI, an HTTP endpoint, or another agent). + +## Scheduling vs immediate self-messaging + +- `Schedule(client, at, in) *ScheduledInvocation` — run at a future `time.Time`. Keep the handle to cancel it: `inv.Cancel()`. +- `Trigger(client, in)` — enqueue immediately, no delay (use it to advance a state machine to the next step now). +- **Never self-`Call`** — a synchronous call into the same instance deadlocks (one instance processes one invocation at a time). Self-messaging must use `Trigger` or `Schedule`. + +## Key Constraints + +- The self `ID` must come from the constructor (or be reconstructable) — `Context` exposes only `AgentID() string`, not the typed `ID`. +- The reschedule must live in the tick handler itself (a package-level descriptor referencing its own handler in an `init()` is fine; there is no var-initialization cycle because the handler is registered in `init`, not in a `var` initializer). +- Compute the next time with `time.Now().Add(interval)`; the scheduled time is recorded durably. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-fire-and-forget-go` | Enqueue an immediate invocation (`Trigger`) | +| `golem-call-another-agent-go` | Await a result from another agent | +| `golem-add-agent-go` | Define the agent | diff --git a/golem-skills/skills/go/golem-retry-policies-go/SKILL.md b/golem-skills/skills/go/golem-retry-policies-go/SKILL.md new file mode 100644 index 0000000000..52a9e2cbd1 --- /dev/null +++ b/golem-skills/skills/go/golem-retry-policies-go/SKILL.md @@ -0,0 +1,299 @@ +--- +name: golem-retry-policies-go +description: "Configuring semantic retry policies for a Go Golem agent. Use when the user asks about retry policies, retry strategies, exponential backoff, transient error recovery, retry predicates, the retry subpackage, Named/Set/With, Policy or Predicate builders, jitter, MaxRetries, Clamp, AndThen, or customizing how failures are retried in a Go Golem project." +--- + +# Configuring Semantic Retry Policies (Go) + +Golem retries retriable operations (RPC, HTTP, RDBMS, and whole-invocation traps) +according to **named policy rules**. Each rule is a `retry.NamedPolicy`: a +`retry.Policy` (the strategy) plus a `retry.Predicate` deciding when it applies and +a priority. Per operation, the runtime resolves the highest-priority rule whose +predicate matches and applies its policy. + +Rules come from three tiers, and the Go `retry` subpackage +(`github.com/golemcloud/golem/sdks/go/golem/retry`) works with all of them: + +- **Manifest** (`golem.yaml`) or CLI — operator-tuned base rules; the code reads + them back. +- **Code-owned** — `retry.Set(...)` registers a rule that persists for the agent. +- **Per-call** — `retry.With(...)` overrides a rule for one call, restored on return. + +## Steps + +1. **Declare base rules** in `golem.yaml` (`retryPolicyDefaults`), scoped per environment. +2. **Build strategies in code** from a base policy plus fluent combinators. +3. **Apply** them: `retry.Set` for code-owned rules (often in the constructor), `retry.With` for per-call overrides. +4. **Query** active rules with `retry.GetByName` / `retry.GetPolicies` / `retry.PolicyNames`. + +## 1. Define Retry Policies in the Application Manifest + +Add definitions under `retryPolicyDefaults` in `golem.yaml`, scoped per +environment. This is platform-level config (shared with the other language SDKs): + +```yaml +retryPolicyDefaults: + prod: + http-transient: + priority: 10 + predicate: + and: + - propEq: { property: "error-type", value: "transient" } + - propEq: { property: "uri-scheme", value: "https" } + policy: + countBox: + maxRetries: 5 + inner: + jitter: + factor: 0.15 + inner: + clamp: + minDelay: "100ms" + maxDelay: "5s" + inner: + exponential: + baseDelay: "200ms" + factor: 2.0 + catch-all: + priority: 0 + predicate: true + policy: + countBox: + maxRetries: 3 + inner: + exponential: + baseDelay: "100ms" + factor: 3.0 +``` + +Policies are evaluated in **descending priority order**; the first matching +predicate's policy wins. If none match, the built-in `default` (3 retries, +exponential backoff, clamped to [100ms, 1s], 15% jitter) applies. + +## 2. Build and Apply Policies in Code + +Use the `retry` subpackage. A `Policy`/`Predicate`/`NamedPolicy` is an **immutable +value**; combinators return a new value, so malformed graphs are unrepresentable. + +```go +import ( + "time" + + "github.com/golemcloud/golem/sdks/go/golem/retry" +) + +pol := retry.Exponential(200*time.Millisecond, 2.0). + Clamp(100*time.Millisecond, 5*time.Second). + WithJitter(0.15). + OnlyWhen(retry.ErrorType.Eq("transient")). + MaxRetries(5) + +rule := retry.Named("http-transient", pol). + WithPriority(10). + AppliesWhen(retry.URIScheme.Eq("https")) +``` + +### Base policies + +| Constructor | Description | +|---|---| +| `retry.Periodic(d)` | Fixed delay between attempts | +| `retry.Exponential(base, factor)` | `base × factor^attempt` — exponentially growing delays (factor finite, > 0) | +| `retry.Fibonacci(first, second)` | Fibonacci-growing delay seeded by `first`, `second` | +| `retry.Immediate()` | Retry with no delay | +| `retry.Never()` | Do not retry | + +### Combinators (methods on `Policy`) + +| Method | Description | +|---|---| +| `.MaxRetries(n)` | Cap the number of retries | +| `.Within(d)` | Stop retrying once a wall-clock budget elapses | +| `.Clamp(minD, maxD)` | Bound each computed delay to `[minD, maxD]` (`minD <= maxD`) | +| `.AddDelay(d)` | Add a fixed offset to each delay | +| `.WithJitter(factor)` | Randomize each delay by up to `factor` (finite, >= 0) | +| `.OnlyWhen(pred)` | Apply the strategy only when `pred` matches; otherwise give up | +| `.AndThen(next)` | Fall back to `next` once this policy stops retrying | +| `.Union(other)` | Retry if either would retry (shorter delay wins) | +| `.Intersect(other)` | Retry only if both would retry (longer delay wins) | + +```go +// Exponential, clamped, jittered, capped: +retry.Exponential(200*time.Millisecond, 2.0). + Clamp(100*time.Millisecond, 5*time.Second). + WithJitter(0.15). + MaxRetries(5) + +// Periodic with a wall-clock budget: +retry.Periodic(time.Second).Within(60 * time.Second) + +// Immediate retries, then fall back to exponential: +retry.Immediate().MaxRetries(3). + AndThen(retry.Exponential(time.Second, 2.0).MaxRetries(5)) + +// Never retry: +retry.Never() +``` + +### Predicates + +Build a predicate from a property (`retry.PropName`) using a comparison method, +then compose with `.And` / `.Or` / `.Not`: + +```go +// A property comparison: +retry.ErrorType.Eq("transient") +retry.StatusCode.OneOf(500, 502, 503, 504) + +// Compose: +retry.ErrorType.Eq("transient").And(retry.URIScheme.Eq("https")) + +// Always / never: +retry.MatchAlways() +retry.MatchNever() +``` + +`PropName` comparison methods: `.Eq`, `.Neq`, `.Gt`, `.Gte`, `.Lt`, `.Lte`, +`.Exists()`, `.OneOf(...)`, `.MatchesGlob(pat)`, `.StartsWith(prefix)`, +`.Contains(sub)`. Comparison values may be a string, any integer type, or a bool. + +### Available properties + +Exported `retry.PropName` constants (use `retry.Prop("name")` for any other): + +| Constant | Populated in | +|---|---| +| `retry.Verb` | every context (HTTP method, RDBMS/RPC verb, or `"trap"`) | +| `retry.NounURI`, `retry.URIScheme`, `retry.URIHost`, `retry.URIPort`, `retry.URIPath` | every context (decomposed resource URI) | +| `retry.StatusCode` | outgoing HTTP **response** only | +| `retry.ErrorType` | outgoing HTTP **response** only (`"transient"`, `"http-status"`) | +| `retry.Function` | worker-to-worker RPC call | +| `retry.TargetComponentID`, `retry.TargetAgentType` | worker-to-worker RPC call | +| `retry.DBType` | RDBMS operations (`postgres`, `mysql`, …) | +| `retry.TrapType` | guest WASM trap (`transient-error`, `unknown`, …) | + +A policy keyed on a property **not present in the current context is silently +skipped** for that decision. So a `StatusCode`-keyed policy fires only for HTTP +responses, a `TrapType`-keyed policy only from the trap path — design one policy +per context (or use `.Or`/`.And` to match several) rather than expecting one policy +to cover everything. + +### Apply: `Set` (code-owned) and `With` (per-call) + +`retry.Set` registers/overwrites a rule and **persists** it for the agent (it +takes precedence over a manifest/CLI rule of the same name). Reach for it when the +code owns the rule — often in the constructor. Both `Set` and `With` **panic** on +an invalid policy (check first with `NamedPolicy.Validate()`). + +```go +var codeOwned = retry.Named("code-owned", + retry.Exponential(100*time.Millisecond, 2.0). + Clamp(50*time.Millisecond, 2*time.Second). + OnlyWhen(retry.StatusCode.Gte(500)). + MaxRetries(4)). + WithPriority(20). + AppliesWhen(retry.TargetAgentType.Eq("InventoryAgent")) + +var agent = golem.Implement(retrying.Agent, func(retrying.ID) *state { + retry.Set(codeOwned) // register the code-owned rule when the worker starts + return &state{} +}) +``` + +`retry.With` applies a rule for the **current call only** and returns a `restore` +function that reinstates the previously registered rule (or removes it) — scope it +with `defer`: + +```go +golem.Handle(agent, retrying.Burst, func(_ *golem.Context[state], _ golem.Unit) retrying.Snapshot { + // Override the code-owned rule just for this call, restored on return. + defer retry.With(retry.Named("code-owned", retry.Immediate().MaxRetries(10)). + WithPriority(99). + AppliesWhen(retry.TargetAgentType.Eq("InventoryAgent")))() + return doWork() +}) +``` + +`retry.Remove(name)` deletes a rule. + +> **Concurrency.** `Set`, `Remove`, and `With` apply at the **worker level**, not +> per goroutine. `With` is safe as long as its scope does not await while other +> goroutines run concurrently; don't hold an override open across a `CallAsync` +> fan-out. + +## 3. Query Policies at Runtime + +```go +// Names only (cheap — does not decode bodies): +names := retry.PolicyNames() + +// Fully decoded rules: +policies, err := retry.GetPolicies() +if err == nil { + for _, p := range policies { + _ = p.Name() // string + _ = p.Priority() // uint32 + } +} + +// A specific rule by name: +np, found, err := retry.GetByName("http-transient") +if err == nil && found { + _ = np.Priority() +} + +// What policy the runtime would pick for a hypothetical operation: +pol, matched, err := retry.Resolve("GET", "https://api.example.com/x", + map[string]any{"status-code": 503}) +_ = pol +_ = matched +_ = err +``` + +`NamedPolicy` accessors: `.Name()`, `.Priority()`, `.Strategy()` (opaque `Policy`), +`.Applicability()` (`Predicate`), and `.Validate()` (returns the first lowering +error, or nil). + +## 4. Live-Editing Policies via CLI + +Retry policies can be managed at runtime without redeployment (takes effect +immediately for running agents): + +```shell +golem retry-policy create http-transient \ + --priority 10 \ + --predicate '{ "and": [{ "propEq": { "property": "error-type", "value": "transient" } }, { "propEq": { "property": "uri-scheme", "value": "https" } }] }' \ + --policy '{ "countBox": { "maxRetries": 5, "inner": { "exponential": { "baseDelay": "200ms", "factor": 2.0 } } } }' + +golem retry-policy list +golem retry-policy get http-transient +golem retry-policy update http-transient --priority 15 +golem retry-policy delete http-transient +``` + +## 5. Default Retry Policy + +When no user-defined policy matches, Golem uses the built-in `default`: priority +`0`, predicate `true`, up to 3 retries, exponential backoff (factor 3.0), delays +clamped to [100ms, 1s], 15% jitter. + +## Key Constraints + +- `Policy`/`Predicate`/`NamedPolicy` are immutable values; combinators return new + values (build once as package data where possible). +- `retry.Set` and `retry.With` **panic** on an invalid policy — validate first with + `NamedPolicy.Validate()` if the inputs are dynamic. +- Policies are defined **per-environment**; names must be unique within one; higher + priority is evaluated first. +- A property-keyed policy is silently skipped in a context that lacks that property. +- `retry.With` is scoped to the current call — the previous rule is restored on + return; it is worker-global, so mind concurrent awaits. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-make-http-request-go` | The outgoing HTTP calls whose responses drive status-code retries | +| `golem-atomic-block-go` | Idempotence mode and atomic regions interact with retry semantics | +| `golem-call-another-agent-go` | RPC calls retried via `Function` / `TargetAgentType`-keyed rules | +| `golem-add-transactions-go` | Saga transactions layered on durable execution and retries | diff --git a/golem-skills/skills/go/golem-schedule-agent-go/SKILL.md b/golem-skills/skills/go/golem-schedule-agent-go/SKILL.md new file mode 100644 index 0000000000..fa07a7bea8 --- /dev/null +++ b/golem-skills/skills/go/golem-schedule-agent-go/SKILL.md @@ -0,0 +1,100 @@ +--- +name: golem-schedule-agent-go +description: "Scheduling a future invocation on a Go Golem agent from the CLI. Use when the user asks to schedule, delay, or plan a future agent method invocation in a Go Golem project." +--- + +# Scheduling a Future Agent Invocation from the CLI + +## Overview + +The `--schedule-at` flag on `golem agent invoke` schedules the invocation to execute at a specific future time. It **requires** the `--trigger` flag, because scheduled invocations are always fire-and-forget — the CLI returns immediately after the invocation is enqueued, and the Golem runtime executes it when the scheduled time arrives. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Pick the method** and any arguments (e.g. `increment`, `add 5`). +3. **Choose the time** in ISO 8601 / RFC 3339 format with a timezone. +4. **Run `golem agent invoke --trigger --schedule-at `** — the CLI returns immediately. + +## Usage + +```shell +golem agent invoke --trigger --schedule-at [ARGUMENTS...] +``` + +## DateTime Format + +The `--schedule-at` value must be in **ISO 8601 / RFC 3339** format with a timezone: + +``` +2026-03-15T10:30:00Z # UTC +2026-03-15T10:30:00+02:00 # With timezone offset +``` + +## Examples + +### Schedule a method to run at a specific time + +```shell +golem agent invoke --trigger --schedule-at 2026-03-15T10:30:00Z 'CounterAgent("my-counter")' increment +``` + +### Schedule with an argument + +```shell +golem agent invoke --trigger --schedule-at 2026-04-01T00:00:00Z 'CounterAgent("my-counter")' add 5 +``` + +### Schedule in a specific environment + +```shell +golem agent invoke --trigger --schedule-at 2026-03-15T08:00:00Z 'production/CounterAgent("my-counter")' increment +``` + +### Schedule with an idempotency key for deduplication + +```shell +golem agent invoke --trigger --schedule-at 2026-03-15T10:30:00Z -i 'increment-2026-03-15' 'CounterAgent("my-counter")' increment +``` + +## Available Options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | **Required** with `--schedule-at`. Fire-and-forget mode | +| `--schedule-at ` | The time to execute the invocation (ISO 8601 / RFC 3339) | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | + +## How It Works + +1. The CLI sends the invocation request with the scheduled time to the Golem server. +2. The server enqueues the invocation to execute at the specified time. +3. The CLI returns immediately with the idempotency key. +4. At the scheduled time, the Golem runtime executes the invocation. + +## Value Syntax + +Agent ID parameters and method arguments use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- `--schedule-at` requires `--trigger`; a scheduled invocation is always fire-and-forget. +- The datetime must include a timezone (RFC 3339); use `Z` for UTC. +- Scheduled invocations use idempotency keys just like regular invocations — the same key is not executed more than once. +- To schedule a future call from **inside agent code** (rather than the CLI), use `Method.Schedule` — see `golem-schedule-future-call-go`. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-schedule-future-call-go` | Schedule a future call from *agent code* (`Method.Schedule`) | +| `golem-trigger-agent-go` | Fire-and-forget invocation without a schedule | +| `golem-invoke-agent-go` | Synchronous invocation that waits for the result | +| `golem-recurring-task-go` | A self-rescheduling / periodic task in agent code | diff --git a/golem-skills/skills/go/golem-schedule-future-call-go/SKILL.md b/golem-skills/skills/go/golem-schedule-future-call-go/SKILL.md new file mode 100644 index 0000000000..150aecd7f1 --- /dev/null +++ b/golem-skills/skills/go/golem-schedule-future-call-go/SKILL.md @@ -0,0 +1,109 @@ +--- +name: golem-schedule-future-call-go +description: "Scheduling a one-off future agent call from Go agent code, and canceling it. Use when the user wants a delayed invocation, a timed call for later, or to cancel a pending scheduled call in a Go Golem project." +--- + +# Scheduling a Future Agent Call from Go Code + +## Overview + +`Method.Schedule(client, at, in)` enqueues a **one-off** invocation of a method to run at a specific future time. It returns a `*golem.ScheduledInvocation`, whose `Cancel()` prevents the invocation if it has not started yet. + +Like `Trigger`, `Schedule` does not wait for a result — so it is safe to target **another** agent or the **same** instance (a synchronous self-`Call` would deadlock). The scheduled time is recorded durably and survives restarts. + +For a task that **reschedules itself** on an interval (a periodic / cron-like loop), see `golem-recurring-task-go`; this skill covers scheduling a single future call and canceling it. + +## Steps + +1. **Get a client** for the target instance: `counter.Agent.Get(counter.ID{Name: "my-counter"})`. +2. **Schedule the method** at a `time.Time`: `counter.Increment.Schedule(c, when, in)`. +3. **Keep the returned `*golem.ScheduledInvocation`** if you may need to cancel it. +4. **Cancel** with `inv.Cancel()` before the scheduled time to prevent it. + +## Scheduling a future call on another agent + +```go +package impl + +import ( + "time" + + "myapp/agents/counter" + "myapp/agents/scheduler" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ pending *golem.ScheduledInvocation } + +var agent = golem.Implement(scheduler.Agent, func(scheduler.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, scheduler.Arm, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + c := counter.Agent.Get(counter.ID{Name: "my-counter"}) + // Run counter.increment 60 seconds from now. + ctx.State.pending = counter.Increment.Schedule(c, time.Now().Add(60*time.Second), golem.Unit{}) + return golem.Unit{} + }) +} +``` + +`Schedule` returns a `*golem.ScheduledInvocation`; its `ID` field is the invocation's `InvocationID`. + +### Scheduling a method that takes arguments + +Pass the method's input value as the last argument, exactly as with `Call` / `Trigger`: + +```go +c := counter.Agent.Get(counter.ID{Name: "my-counter"}) +counter.Add.Schedule(c, time.Now().Add(24*time.Hour), counter.AddIn{By: 5}) +``` + +## Canceling a scheduled call + +Keep the `*golem.ScheduledInvocation` (e.g. in state) and call `Cancel()`: + +```go +func init() { + golem.Handle(agent, scheduler.Cancel, func(ctx *golem.Context[state], _ golem.Unit) golem.Unit { + if ctx.State.pending != nil { + ctx.State.pending.Cancel() // no-op if it has already started + ctx.State.pending = nil + } + return golem.Unit{} + }) +} +``` + +`Cancel()` is idempotent: it does nothing if already canceled, and cannot un-run an invocation that has already started. + +## Scheduling a future call to itself + +To message its own instance an agent needs a client for its own `ID`. `Context` exposes only the id string, so capture the typed `ID` in state at construction (see `golem-recurring-task-go` for the full pattern): + +```go +self := counter.Agent.Get(ctx.State.self) // ctx.State.self captured in the constructor +counter.Increment.Schedule(self, time.Now().Add(time.Minute), golem.Unit{}) +``` + +## Schedule vs Trigger + +- `Schedule(c, at, in) *ScheduledInvocation` — run once at a future `time.Time`; cancelable via `Cancel()`. +- `Trigger(c, in) InvocationID` — enqueue immediately, no delay, not cancelable. Use it to advance to the next step now. +- Never self-`Call` — a synchronous call into the same instance deadlocks; self-messaging must use `Schedule` or `Trigger`. + +## Key Constraints + +- `Schedule` / `Trigger` are called on the **method descriptor** (`counter.Increment.Schedule(c, ...)`), and the client comes from the callee's **definition** (`counter.Agent.Get(id)`). +- Compute the time with `time.Now().Add(d)` (a `time.Time`); it is recorded durably. +- To cancel later, you must retain the `*golem.ScheduledInvocation` — don't discard it if cancellation may be needed. Hold it in agent state, not across a bare `var` initializer. +- For a self-scheduling recurring loop, don't hand-roll it here — use `golem-recurring-task-go`. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-recurring-task-go` | A self-rescheduling / periodic (cron-like) task | +| `golem-fire-and-forget-go` | Enqueue an immediate invocation (`Trigger`) | +| `golem-call-another-agent-go` | Await a result from another agent (`Call` / `CallAsync`) | +| `golem-schedule-agent-go` | Schedule a future invocation from the CLI | diff --git a/golem-skills/skills/go/golem-stateless-agent-go/SKILL.md b/golem-skills/skills/go/golem-stateless-agent-go/SKILL.md new file mode 100644 index 0000000000..21ac8584e2 --- /dev/null +++ b/golem-skills/skills/go/golem-stateless-agent-go/SKILL.md @@ -0,0 +1,141 @@ +--- +name: golem-stateless-agent-go +description: "Creating ephemeral (stateless) agents in a Go Golem project. Use when the user wants a stateless agent, a fresh instance per invocation, no shared state between calls, or a request-handler style agent in a Go Golem project." +--- + +# Creating Ephemeral (Stateless) Agents (Go) + +## Overview + +An **ephemeral agent** gets a **fresh instance for every invocation**. Unlike the default durable agents, an ephemeral agent: + +- **Has no shared state** — each invocation starts from a clean init function; values set in one call are gone by the next. +- **Is not replayed** — an oplog is still recorded lazily (inspectable via `golem agent oplog`), but it is never used to replay/recover. +- **Discards its memory** after each invocation completes. +- **Keeps the same identity model** — still addressed by its constructor parameters (`ID`), but every call behaves as if the agent was just created. + +This fits **pure request handlers**, **stateless transformers**, **adapters**, and **serverless-style functions** where each call is independent. + +## How to make an agent ephemeral + +Set `Mode: golem.Ephemeral` on the `Spec`. `Mode` defaults to `golem.Durable`. + +```go +// Package handler is the DEFINITION of a stateless request-handler agent. +package handler + +import "github.com/golemcloud/golem/sdks/go/golem" + +// An ID with no fields is a singleton identity; add fields to address variants. +type ID struct{} + +type HandleIn struct{ Input string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "RequestHandlerAgent", + Description: "Stateless request handler — fresh instance per invocation", + Mode: golem.Ephemeral, // <- makes every invocation start clean +}) + +var Handle = golem.DefineMethod[ID, HandleIn, string]("handle", + golem.Desc("Process one request and return the result")) +``` + +### Implementation + +The implementation is written exactly like a durable agent's — the `state` type just holds nothing meaningful across calls (or is empty), because it is recreated each invocation: + +```go +package impl + +import ( + "strings" + + "myapp/agents/handler" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state is empty: an ephemeral agent keeps nothing between invocations. +type state struct{} + +var agent = golem.Implement(handler.Agent, func(handler.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, handler.Handle, func(_ *golem.Context[state], in handler.HandleIn) string { + return "processed: " + strings.ToUpper(in.Input) + }) +} +``` + +## What "fresh instance per invocation" means + +The only difference from a durable agent is `Mode`: + +```go +// DURABLE (default) — state accumulates across calls. +var Durable = golem.DefineAgent[ID](golem.Spec{Name: "DurableCounter"}) +// increment() three times → 1, 2, 3 + +// EPHEMERAL — state resets every call. +var Ephemeral = golem.DefineAgent[ID](golem.Spec{Name: "EphemeralCounter", Mode: golem.Ephemeral}) +// increment() three times → 1, 1, 1 +``` + +Each invocation of an ephemeral agent: +1. Runs the init function (`func(ID) *state`) to build a fresh state. +2. Executes the method handler. +3. Discards the instance entirely. + +## Combining with HTTP endpoints + +Ephemeral agents are a natural fit for HTTP request handlers — declare an HTTP mount alongside `Mode: golem.Ephemeral`: + +```go +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ConverterAgent", + Mode: golem.Ephemeral, + HTTP: &golem.Mount{Path: "/api/convert/{name}"}, +}) + +var ( + ToUpper = golem.DefineMethod[ID, ConvertIn, string]("toUpper", + golem.HTTP(golem.POST("/to-upper"))) + ToLower = golem.DefineMethod[ID, ConvertIn, string]("toLower", + golem.HTTP(golem.POST("/to-lower"))) +) +``` + +## When to use ephemeral agents + +| Use case | Why ephemeral | +|----------|---------------| +| Stateless HTTP API (REST adapter, proxy) | No state to persist between requests | +| Data transformation / format conversion | Pure function — input in, output out | +| Validation service | Each validation is independent | +| Webhook receiver that forwards events | No need to remember previous events | +| Stateless computation (math, encoding) | No side effects worth persisting | + +## When NOT to use ephemeral agents + +- **Counters, accumulators, shopping carts** — need state across calls → use durable (default). +- **Workflow orchestrators, sagas** — need the oplog for recovery → use durable (default). +- **Agents where at-least-once semantics on external effects matter** → use durable (default). +- **Any agent where one call's result depends on a previous call** → use durable (default). + +## Key Constraints + +- Ephemeral mode is set at the **agent type level** (`Spec.Mode`) — all instances of the type are ephemeral. +- Constructor parameters still define identity — different `ID` values are still distinct addressable agents. +- Ephemeral agents can still call other agents (RPC), make HTTP requests, and use the rest of the SDK — they simply don't retain state or replay. +- The oplog is recorded lazily (inspectable via `golem agent oplog`) but is never replayed for recovery. +- State-only durability features (snapshotting, atomic blocks over persisted state) have nothing to persist here; leave `Spec.Snapshot` at its default. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-add-agent-go` | Define the agent and its methods (durable baseline) | +| `golem-add-http-endpoint-go` | Expose the stateless agent over HTTP | +| `golem-call-another-agent-go` | An ephemeral agent calling other agents | +| `golem-configure-durability-go` | Durability controls for the durable alternative | diff --git a/golem-skills/skills/go/golem-trigger-agent-go/SKILL.md b/golem-skills/skills/go/golem-trigger-agent-go/SKILL.md new file mode 100644 index 0000000000..c779728a1f --- /dev/null +++ b/golem-skills/skills/go/golem-trigger-agent-go/SKILL.md @@ -0,0 +1,100 @@ +--- +name: golem-trigger-agent-go +description: "Triggering a fire-and-forget invocation on a Go Golem agent from the CLI. Use when the user asks to trigger, enqueue, or fire-and-forget an agent method invocation in a Go Golem project." +--- + +# Triggering a Fire-and-Forget Agent Invocation + +## Overview + +The `--trigger` (or `-t`) flag on `golem agent invoke` sends the invocation request to the agent and **returns immediately** without waiting for the result. The invocation is enqueued and executed asynchronously by the Golem runtime. + +Both `golem` and `golem-cli` can be used — every command below works with either binary. + +## Steps + +1. **Identify the agent** by its type name and constructor parameters (`CounterAgent("my-counter")`). +2. **Pick the method** to enqueue (e.g. `increment`, `add`). +3. **Run `golem agent invoke --trigger`** — the CLI returns as soon as the invocation is accepted. + +## Usage + +```shell +golem agent invoke --trigger [ARGUMENTS...] +``` + +## When to Use Trigger + +- When the caller does not need the return value +- When you want to start a long-running operation without blocking +- When enqueuing work for background processing +- When combined with `--schedule-at` for future execution (see `golem-schedule-agent-go`) + +## Examples + +### Trigger a method with no wait + +```shell +golem agent invoke --trigger 'CounterAgent("my-counter")' increment +``` + +### Trigger with an argument + +`add` takes one parameter (the `By` field of `AddIn`), passed positionally: + +```shell +golem agent invoke --trigger 'CounterAgent("my-counter")' add 5 +``` + +### Trigger in a specific environment + +```shell +golem agent invoke --trigger 'staging/CounterAgent("my-counter")' increment +``` + +### Trigger with an explicit idempotency key + +```shell +golem agent invoke --trigger -i 'increment-2026-01-15' 'CounterAgent("my-counter")' increment +``` + +## Available Options + +| Option | Description | +|--------|-------------| +| `-t, --trigger` | **Required.** Trigger the invocation without waiting | +| `-i, --idempotency-key ` | Set a specific idempotency key; use `"-"` for auto-generated | +| `--no-stream` | Disable live streaming of agent stdout/stderr/log | +| `--schedule-at ` | Schedule the invocation at a specific time (ISO 8601 format, e.g. `2026-03-15T10:30:00Z`) | + +## Difference from Regular Invoke + +| | `golem agent invoke` | `golem agent invoke --trigger` | +|---|---|---| +| Waits for result | Yes | No | +| Returns value | Yes | Only the idempotency key | +| Streams output | Yes (by default) | No | +| Use case | Synchronous calls | Fire-and-forget / background work | + +## Value Syntax + +Agent ID parameters and method arguments use the CLI's WIT value syntax: + +- Strings are quoted: `"my-counter"`; integers are bare: `5`; booleans are `true` / `false`. +- Each exported field of a Go input struct is one positional WIT parameter, named by lower-camel-casing the Go field name (`AmountCents` → `amountCents`). +- Options: `some(value)` / `none`. Records: `{ field-one: 1, field-two: "hello" }`. Tuples: `(1, "hello")`. + +## Key Constraints + +- Triggered invocations still use idempotency keys — the same key is not executed twice. +- There is no way to read a return value from a triggered invocation; use plain `golem agent invoke` when you need the result. +- If the component is not deployed yet and the CLI runs from an application directory, the command auto-builds and deploys it before triggering. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-invoke-agent-go` | Synchronous invocation that waits for the result | +| `golem-schedule-agent-go` | Combine `--trigger` with `--schedule-at` for future execution | +| `golem-fire-and-forget-go` | Fire-and-forget invocation from *agent code* (`Trigger`) | +| `golem-create-agent-instance-go` | Pre-create an agent instance (`golem agent new`) | diff --git a/golem-skills/skills/go/golem-wait-for-external-input-go/SKILL.md b/golem-skills/skills/go/golem-wait-for-external-input-go/SKILL.md new file mode 100644 index 0000000000..5db3ecf946 --- /dev/null +++ b/golem-skills/skills/go/golem-wait-for-external-input-go/SKILL.md @@ -0,0 +1,168 @@ +--- +name: golem-wait-for-external-input-go +description: "Waiting for external input using Golem promises in a Go Golem project. Use when the user asks about promises, waiting for external events, human-in-the-loop workflows, pausing an agent until an external signal, or suspending execution until data arrives from outside in a Go Golem project." +--- + +# Waiting for External Input with Golem Promises (Go) + +## Overview + +A **Golem promise** lets an agent suspend its execution until an external event completes it. The agent creates a promise, hands the promise ID to an external system (another agent, a webhook, a UI, an HTTP API call), and then awaits the result. The Golem runtime **durably suspends** the invocation — consuming no resources, surviving restarts, exactly-once via oplog replay — until the promise is fulfilled. + +In Go a promise is a typed handle `golem.Promise[T]`: the completion payload is decoded as `T` via JSON (or passed through unchanged when `T` is `[]byte`). + +## Steps + +1. **Create a promise** inside a handler with `golem.NewPromise[T]()`. +2. **Persist its ID** (`p.ID()`) in the agent's state, and/or hand it to the outside world so someone can complete it later. +3. **Await it** with `golem.PromiseByID[T](id).Await()` (or `p.Await()` in the same invocation) — the invocation durably suspends here. +4. **Complete it** from another agent with `golem.CompletePromise(id, value)`, or from off-platform via the worker REST endpoint / a minted `WebhookURL()`. + +## API (from `promise.go`) + +| Function / Method | Signature | Description | +|-------------------|-----------|-------------| +| `golem.NewPromise[T]` | `func NewPromise[T any]() *Promise[T]` | Create a fresh promise owned by the current agent | +| `golem.PromiseByID[T]` | `func PromiseByID[T any](id PromiseID) *Promise[T]` | Rebuild a handle from a stored `PromiseID` | +| `(*Promise[T]).ID` | `func (p *Promise[T]) ID() PromiseID` | The durable identity to persist or hand out | +| `(*Promise[T]).Await` | `func (p *Promise[T]) Await() T` | Durably block until completed; returns the payload as `T` | +| `(*Promise[T]).WebhookURL` | `func (p *Promise[T]) WebhookURL() string` | Mint an external URL whose POST body completes the promise | +| `golem.CompletePromise[T]` | `func CompletePromise[T any](id PromiseID, value T) bool` | Complete a promise from another agent; returns `false` if already completed | + +`Await` is **fail-loud**: an infra failure traps and surfaces as an agent-error rather than returning an `error`. Only the agent that created the promise may `Await` it — awaiting from another agent traps in the host. + +## `PromiseID` structure + +`golem.PromiseID` has three exported (JSON-marshalable) fields, which are exactly what the REST complete endpoint needs: + +```go +type PromiseID struct { + ComponentID golem.UUID // the component the owning agent belongs to + AgentID string // agent type + constructor params (the ":agent" path segment) + OplogIndex uint64 // disambiguates promises from the same agent ("oplogIdx") +} +``` + +## Full example: human-in-the-loop approval + +### Definition (`agents/approval/approval.go`) + +```go +// Package approval is the DEFINITION of the human-in-the-loop approval agent. +package approval + +import "github.com/golemcloud/golem/sdks/go/golem" + +// Verdict is the promise payload, typed as JSON by golem.Promise. +type Verdict struct { + Approved bool + Reason string +} + +type ID struct{ Queue string } + +var Agent = golem.DefineAgent[ID](golem.Spec{ + Name: "ApprovalAgent", + Description: "Human-in-the-loop approvals via durable promises", +}) + +var ( + // Request opens the promise and returns its id for an external completer. + Request = golem.DefineMethod[ID, golem.Unit, golem.PromiseID]("request", + golem.Desc("Open an approval request, returning the promise id to complete")) + // Await durably blocks until the open request is completed. + Await = golem.DefineMethod[ID, golem.Unit, Verdict]("await", + golem.Desc("Durably block until the open request is completed")) +) +``` + +### Implementation (`agents/approval/impl/impl.go`) + +```go +// Package impl is the IMPLEMENTATION of the approval agent. Await durably +// SUSPENDS the invocation until the promise is completed. +package impl + +import ( + "myapp/agents/approval" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state remembers the open promise across invocations. +type state struct { + pending golem.PromiseID + open bool +} + +var agent = golem.Implement(approval.Agent, func(approval.ID) *state { return &state{} }) + +func init() { + golem.Handle(agent, approval.Request, func(ctx *golem.Context[state], _ golem.Unit) golem.PromiseID { + p := golem.NewPromise[approval.Verdict]() + ctx.State.pending = p.ID() // persist so a later invocation can Await it + ctx.State.open = true + return p.ID() + }) + + golem.Handle(agent, approval.Await, func(ctx *golem.Context[state], _ golem.Unit) approval.Verdict { + if !ctx.State.open { + panic("no open approval request — call request first") + } + // Rebuild the handle from the stored id and durably suspend until completion. + return golem.PromiseByID[approval.Verdict](ctx.State.pending).Await() + }) +} +``` + +## Completing from another agent + +```go +// From any agent — agent-to-agent completion: +ok := golem.CompletePromise(pendingID, approval.Verdict{Approved: true, Reason: "looks good"}) +_ = ok // false means it was already completed (idempotency signal) +``` + +## Completing from outside Golem (REST) + +Hand the three `PromiseID` fields to the external system; it POSTs to the worker-service complete endpoint: + +```shell +curl -X POST \ + "$GOLEM_URL/v1/components/$COMPONENT_ID/workers/$AGENT_ID/complete" \ + -H 'Content-Type: application/json' \ + -d '{"oplogIdx": , "data": []}' +``` + +The `data` bytes become the payload `Await` decodes as `T` (JSON when `T` is a struct). + +## Webhook-style callback + +When the agent type is HTTP-API-deployed (its `Spec.HTTP` is set and it is declared in the manifest's `httpApi` deployment), mint a URL whose POST body completes the promise: + +```go +p := golem.NewPromise[Event]() +url := p.WebhookURL() // hand this to an off-platform system; its POST body completes the promise +ctx.State.pending = p.ID() +// later, in another invocation: +event := golem.PromiseByID[Event](ctx.State.pending).Await() +``` + +`WebhookURL` is fail-loud: it traps if the agent is not HTTP-API-deployed. + +## Key Constraints + +- The promise payload is typed as `T` via JSON. Use `golem.Promise[[]byte]` as an escape hatch to carry raw, non-JSON bytes through unchanged. +- Only the **creating** agent may `Await` a promise; awaiting from a different agent traps. +- Persist `p.ID()` in the agent's state if the promise is created in one invocation and awaited in another — a single agent processes invocations sequentially, so `Request` returns before `Await` runs. +- `Await` is fail-loud (traps on infra failure), matching Golem's exactly-once model — do not expect an `error` return. +- `CompletePromise` returns `false` if the promise was already completed; treat it as the idempotency signal, not a failure. + +### Related Skills + +| Skill | When to Load | +|-------|--------------| +| `golem-call-another-agent-go` | An agent completes another agent's promise via RPC | +| `golem-parallel-workers-go` | Fan out work and collect results via promises | +| `golem-add-http-endpoint-go` | Expose the agent over HTTP so `WebhookURL` works | +| `golem-add-agent-go` | Define the agent that creates the promise | diff --git a/golem-worker-executor/tests/agent_sdk_go/atomic_region.rs b/golem-worker-executor/tests/agent_sdk_go/atomic_region.rs new file mode 100644 index 0000000000..2f015356c6 --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/atomic_region.rs @@ -0,0 +1,147 @@ +// 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. + +//! What may be done inside an atomic region. A durable call started in the region +//! must settle before the region closes — the executor refuses to end a region +//! while a non-re-executable durable call it started is still in flight. Today a +//! cross-agent RPC settles and an outbound HTTP call does not, so these two tests +//! pin down exactly where the boundary is. + +use crate::Tracing; +use axum::Router; +use axum::extract::Query; +use axum::routing::get; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use serde::Deserialize; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; +use tracing::Instrument; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// IGNORED — this currently fails: the executor refuses to end the region with +/// "Cannot end atomic region N: non-re-executable durable calls initiated in it +/// are still in flight". The region holds a lease per durable call it started +/// (durable_host/mod.rs `ActiveAtomicRegion.members`, weak refs kept alive by the +/// call's handle), and the outbound HTTP call's lease is still surviving at close. +/// +/// Attempts that did NOT fix it (don't repeat blindly): +/// - waiting for the "handled ok" future's writer goroutine to finish before +/// returning from Body.Close (no effect); +/// - dropping the response trailers future in Body.Close (no effect); +/// - dropping the done/trailers future WRITERS after their write — this DOES +/// clear the atomic-region error, but the invocation then hangs to the test +/// timeout, so it breaks the protocol somewhere else. +/// Checked and not the cause: `Send` consumes the request handle and +/// `consume-body` consumes the response handle, so neither leaks. +/// +/// Rust's `transactions.rs` performs HTTP inside atomic regions successfully, so +/// this is a Go-transport gap, not a platform limitation. +#[test] +#[ignore = "GOL-486: outbound HTTP inside an atomic region keeps a non-repairable durable call in flight, so the region cannot close"] +#[tracing::instrument] +#[timeout("2m")] +async fn go_atomic_region_with_outgoing_http( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap(); + let port = listener.local_addr().unwrap().port(); + + #[derive(Deserialize)] + struct QueryParams { + payload: String, + } + + let server = tokio::spawn( + async move { + let route = Router::new().route( + "/callback", + get(move |query: Query| async move { query.payload.clone() }), + ); + axum::serve(listener, route).await.unwrap(); + } + .in_current_span(), + ); + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("HttpAgent", "go-atomic-http-1"); + let mut env = HashMap::new(); + env.insert("PORT".to_string(), port.to_string()); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), env, Vec::new()) + .await?; + + let body = executor + .invoke_and_await_agent(&component, &agent_id, "atomic-callback", data_value!("inside")) + .await? + .into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + server.abort(); + + assert_eq!(body, "inside"); + Ok(()) +} + +/// A cross-agent RPC inside an atomic region settles, so the region closes +/// normally. This is the pattern the `golem-atomic-block-go` skill documents, and +/// it is what distinguishes GOL-486 from a general atomic-region problem. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_atomic_region_with_rpc( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("RpcAgent", "go-atomic-rpc-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + let total = executor + .invoke_and_await_agent(&component, &agent_id, "atomic-call", data_value!("eu", 5i64)) + .await? + .into_typed::()?; + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + assert_eq!(total, 5); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/blobstore.rs b/golem-worker-executor/tests/agent_sdk_go/blobstore.rs new file mode 100644 index 0000000000..fbe898630a --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/blobstore.rs @@ -0,0 +1,132 @@ +// 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. + +//! The Go SDK's blobstore wrapper against the real host store: objects round-trip +//! with their metadata, listing reflects writes and deletes. + +use crate::Tracing; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// Written objects are readable with the right size, listed in the container, and +/// gone after deletion; reading an absent object yields the wrapper's "not found" +/// answer (empty string). +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_blobstore_round_trip( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("BlobAgent", "go-blob-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + // The container is namespaced by component so parallel tests cannot collide. + let container = format!("{}-go-blob-1", component.id); + + executor + .invoke_and_await_agent( + &component, + &agent_id, + "write", + data_value!(container.clone(), "greeting.txt", "hello"), + ) + .await?; + executor + .invoke_and_await_agent( + &component, + &agent_id, + "write", + data_value!(container.clone(), "other.txt", "x"), + ) + .await?; + + let content = executor + .invoke_and_await_agent( + &component, + &agent_id, + "read", + data_value!(container.clone(), "greeting.txt"), + ) + .await? + .into_typed::()?; + let size = executor + .invoke_and_await_agent( + &component, + &agent_id, + "size", + data_value!(container.clone(), "greeting.txt"), + ) + .await? + .into_typed::()?; + let listed = executor + .invoke_and_await_agent(&component, &agent_id, "list", data_value!(container.clone())) + .await? + .into_typed::>()?; + + executor + .invoke_and_await_agent( + &component, + &agent_id, + "delete", + data_value!(container.clone(), "other.txt"), + ) + .await?; + + let after_delete = executor + .invoke_and_await_agent(&component, &agent_id, "list", data_value!(container.clone())) + .await? + .into_typed::>()?; + let missing = executor + .invoke_and_await_agent(&component, &agent_id, "read", data_value!(container, "gone")) + .await? + .into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(content, "hello"); + assert_eq!(size, 5); + assert_eq!( + listed, + vec!["greeting.txt".to_string(), "other.txt".to_string()] + ); + assert_eq!(after_delete, vec!["greeting.txt".to_string()]); + assert_eq!(missing, ""); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/config.rs b/golem-worker-executor/tests/agent_sdk_go/config.rs new file mode 100644 index 0000000000..ac0d6da13b --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/config.rs @@ -0,0 +1,86 @@ +// 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. + +//! Agent config for the Go SDK: values provided at deploy (a flat key and a +//! nested path) are resolved and read back by a configured agent at runtime. + +use crate::Tracing; +use golem_common::model::worker::AgentConfigEntryDto; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// A configured Go agent reads a flat config value ("greeting") and a nested one +/// ("fee"/"cents") set at deploy time. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_agent_config_read( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .with_agent_config( + "ConfigAgent", + vec![ + AgentConfigEntryDto { + path: vec!["greeting".to_string()], + value: serde_json::Value::String("hello".to_string()).into(), + }, + AgentConfigEntryDto { + path: vec!["fee".to_string(), "cents".to_string()], + value: serde_json::json!(30).into(), + }, + ], + ) + .store() + .await?; + + let agent_id = agent_id!("ConfigAgent", "go-config-1"); + executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + let greeting = executor + .invoke_and_await_agent(&component, &agent_id, "greeting", data_value!()) + .await? + .into_typed::()?; + assert_eq!(greeting, "hello"); + + let cents = executor + .invoke_and_await_agent(&component, &agent_id, "cents", data_value!()) + .await? + .into_typed::()?; + assert_eq!(cents, 30); + + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/durability.rs b/golem-worker-executor/tests/agent_sdk_go/durability.rs new file mode 100644 index 0000000000..c02c07777d --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/durability.rs @@ -0,0 +1,307 @@ +// 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. + +//! The headline durability property for the Go SDK: a side effect recorded in one +//! invocation is REPLAYED from the oplog after an executor restart, not re-run. +//! Mirrors `durability::custom_durability_1`. + +use crate::Tracing; +use axum::Router; +use axum::extract::Query; +use axum::routing::get; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use serde::Deserialize; +use std::collections::HashMap; +use std::sync::Arc; +use std::sync::atomic::{AtomicU32, Ordering}; +use test_r::{inherit_test_dep, test, timeout}; +use tracing::Instrument; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// Pure-state replay: a durable counter's state is rebuilt by replaying its +/// prior invocations after an executor restart — no external I/O, isolating +/// whether basic Go replay is deterministic. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_counter_survives_restart( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("CounterAgent", "go-restart-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + executor + .invoke_and_await_agent(&component, &agent_id, "increment", data_value!()) + .await?; + executor + .invoke_and_await_agent(&component, &agent_id, "add", data_value!(5i64)) + .await?; + executor.check_oplog_is_queryable(&worker_id).await?; + + drop(executor); + let executor = start(deps, &context).await?; + + let value = executor + .invoke_and_await_agent(&component, &agent_id, "value", data_value!()) + .await? + .into_typed::()?; + drop(executor); + + assert_eq!(value, 6); + Ok(()) +} + +/// Wall-clock durability: a `time.Now()` reading recorded in a live invocation is +/// reproduced from the oplog when that invocation is replayed after an executor +/// restart — not re-read as the current time. The agent stores each reading in +/// durable state; after a restart, `first-time` replays the original `record-time` +/// invocation, so the first reading must be unchanged. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_wall_clock_replayed_after_restart( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("ClockAgent", "go-clock-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + let recorded = executor + .invoke_and_await_agent(&component, &agent_id, "record-time", data_value!()) + .await? + .into_typed::()?; + executor.check_oplog_is_queryable(&worker_id).await?; + + // Restart: reading first-time replays the record-time invocation, whose + // time.Now() must reproduce the recorded value from the oplog. + drop(executor); + let executor = start(deps, &context).await?; + + let first = executor + .invoke_and_await_agent(&component, &agent_id, "first-time", data_value!()) + .await? + .into_typed::()?; + drop(executor); + + assert_eq!(first, recorded); + Ok(()) +} + +/// A durable outbound HTTP call made in the first invocation is served from the +/// oplog after a restart rather than re-fetched: the external counter advances +/// once per *live* call, so the second invocation sees "1-b", not "2-b". +/// +/// This also covers the distinct host-completion and guest-delivery boundaries of +/// concurrent P3 calls: replay must not expose the recorded HTTP result before the +/// point where the live execution delivered it to the Go callback, because durable +/// clock and body operations may have occurred between those boundaries. +/// +/// IGNORED — the worker hangs while replaying the recorded call after the restart, +/// reaching the test timeout. Observed: +/// - reproducible: 3/3 locally in isolation, and in CI; +/// - `monotonic_clock::now` calls surround the replayed HTTP operation, i.e. the +/// hang variant of the Go-guest replay divergence rather than an assertion +/// failure; +/// - still reproduces on the newest tree at the time of writing (main +/// 748d19797, wasmtime 252ab61f) and with PR #3771 applied locally; +/// - the other Go runtime tests in this suite pass, including +/// `go_counter_survives_restart` and `go_wall_clock_replayed_after_restart`. +/// +/// This is the regression test for the mixed P2/P3 durable replay fix, so re-check +/// it whenever the replay/delivery machinery changes. +#[test] +#[ignore = "GOL-485: hangs while replaying the recorded outbound-HTTP call after a restart — go-guest replay divergence"] +#[tracing::instrument] +#[timeout("2m")] +async fn go_outgoing_http_replayed_without_network( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let response = Arc::new(AtomicU32::new(0)); + let response_clone = response.clone(); + let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap(); + let host_http_port = listener.local_addr().unwrap().port(); + + #[derive(Deserialize)] + struct QueryParams { + payload: String, + } + + let http_server = tokio::spawn( + async move { + let route = Router::new().route( + "/callback", + get(move |query: Query| async move { + format!( + "{}-{}", + response_clone.fetch_add(1, Ordering::AcqRel), + query.payload + ) + }), + ); + axum::serve(listener, route).await.unwrap(); + } + .in_current_span(), + ); + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("HttpAgent", "go-durability-1"); + let mut env = HashMap::new(); + env.insert("PORT".to_string(), host_http_port.to_string()); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), env, Vec::new()) + .await?; + + let result1 = executor + .invoke_and_await_agent(&component, &agent_id, "callback", data_value!("a")) + .await?; + executor.check_oplog_is_queryable(&worker_id).await?; + + // Restart the executor: the first invocation must replay from the oplog. + drop(executor); + let executor = start(deps, &context).await?; + + let result2 = executor + .invoke_and_await_agent(&component, &agent_id, "callback", data_value!("b")) + .await?; + executor.check_oplog_is_queryable(&worker_id).await?; + + drop(executor); + http_server.abort(); + + assert_eq!(result1.into_typed::()?, "0-a"); + assert_eq!(result2.into_typed::()?, "1-b"); + Ok(()) +} + +/// The custom durability API (`golem.DurableOp`) records an operation once and +/// replays its result from the oplog after a restart. The agent wraps an outbound +/// HTTP call in `DurableOp`; on replay the recorded result is returned without +/// re-running the body, so the external counter advances once per *live* call — +/// the second invocation sees "1-b", not "2-b". A broken `DurableOp` would either +/// re-run the body (advancing the counter) or diverge on replay. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_custom_durable_op_replayed_after_restart( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let response = Arc::new(AtomicU32::new(0)); + let response_clone = response.clone(); + let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap(); + let host_http_port = listener.local_addr().unwrap().port(); + + #[derive(Deserialize)] + struct QueryParams { + payload: String, + } + + let http_server = tokio::spawn( + async move { + let route = Router::new().route( + "/callback", + get(move |query: Query| async move { + format!( + "{}-{}", + response_clone.fetch_add(1, Ordering::AcqRel), + query.payload + ) + }), + ); + axum::serve(listener, route).await.unwrap(); + } + .in_current_span(), + ); + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("CustomDurAgent", "go-customdur-1"); + let mut env = HashMap::new(); + env.insert("PORT".to_string(), host_http_port.to_string()); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), env, Vec::new()) + .await?; + + let result1 = executor + .invoke_and_await_agent(&component, &agent_id, "callback", data_value!("a")) + .await?; + executor.check_oplog_is_queryable(&worker_id).await?; + + // Restart: the first invocation's DurableOp must replay its recorded result + // instead of re-running the body (no second hit to the external counter). + drop(executor); + let executor = start(deps, &context).await?; + + let result2 = executor + .invoke_and_await_agent(&component, &agent_id, "callback", data_value!("b")) + .await?; + executor.check_oplog_is_queryable(&worker_id).await?; + + drop(executor); + http_server.abort(); + + assert_eq!(result1.into_typed::()?, "0-a"); + assert_eq!(result2.into_typed::()?, "1-b"); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/keyvalue.rs b/golem-worker-executor/tests/agent_sdk_go/keyvalue.rs new file mode 100644 index 0000000000..3a91c4aedb --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/keyvalue.rs @@ -0,0 +1,187 @@ +// 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. + +//! The Go SDK's keyvalue wrapper against the real host store: values round-trip, +//! deletion is observable, and a write survives a crash by replaying from the +//! oplog. Mirrors `keyvalue::readwrite_get_returns_the_value_that_was_set`. + +use crate::Tracing; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// A value written through the SDK wrapper is read back, listed, and deleted; +/// reading an absent key yields the wrapper's "not found" answer (empty string). +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_keyvalue_round_trip( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("KvAgent", "go-kv-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + // The bucket is namespaced by component so parallel tests cannot collide. + let bucket = format!("{}-go-kv-1", component.id); + + executor + .invoke_and_await_agent( + &component, + &agent_id, + "set", + data_value!(bucket.clone(), "alpha", "first"), + ) + .await?; + executor + .invoke_and_await_agent( + &component, + &agent_id, + "set", + data_value!(bucket.clone(), "beta", "second"), + ) + .await?; + + let stored = executor + .invoke_and_await_agent( + &component, + &agent_id, + "get", + data_value!(bucket.clone(), "alpha"), + ) + .await? + .into_typed::()?; + let exists = executor + .invoke_and_await_agent( + &component, + &agent_id, + "exists", + data_value!(bucket.clone(), "alpha"), + ) + .await? + .into_typed::()?; + let keys = executor + .invoke_and_await_agent( + &component, + &agent_id, + "keys", + data_value!(bucket.clone(), ""), + ) + .await? + .into_typed::>()?; + + executor + .invoke_and_await_agent( + &component, + &agent_id, + "delete", + data_value!(bucket.clone(), "alpha"), + ) + .await?; + + let after_delete = executor + .invoke_and_await_agent( + &component, + &agent_id, + "get", + data_value!(bucket.clone(), "alpha"), + ) + .await? + .into_typed::()?; + let missing = executor + .invoke_and_await_agent(&component, &agent_id, "get", data_value!(bucket, "nope")) + .await? + .into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(stored, "first"); + assert!(exists); + assert_eq!(keys, vec!["alpha".to_string(), "beta".to_string()]); + assert_eq!(after_delete, ""); + assert_eq!(missing, ""); + Ok(()) +} + +/// A key written before a crash is still readable afterwards: the recorded write +/// replays from the oplog rather than being lost or re-executed. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_keyvalue_survives_crash( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("KvAgent", "go-kv-2"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + let bucket = format!("{}-go-kv-2", component.id); + + executor + .invoke_and_await_agent( + &component, + &agent_id, + "set", + data_value!(bucket.clone(), "key", "value"), + ) + .await?; + + executor.simulated_crash(&worker_id).await?; + + let after_crash = executor + .invoke_and_await_agent(&component, &agent_id, "get", data_value!(bucket, "key")) + .await? + .into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(after_crash, "value"); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/mod.rs b/golem-worker-executor/tests/agent_sdk_go/mod.rs new file mode 100644 index 0000000000..e3bf4c11b0 --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/mod.rs @@ -0,0 +1,95 @@ +// 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. + +//! Runtime tests for the Go SDK, driven through the `agent-sdk-go` guest (built +//! by `test-components/build-components.sh go`). This is the foundational suite — +//! more scenarios (durability/replay, RPC, config, …) build on this wiring. + +pub mod atomic_region; +pub mod blobstore; +pub mod config; +pub mod durability; +pub mod keyvalue; +pub mod promise; +pub mod rich_types; +pub mod retry; +pub mod revert; +pub mod schedule; +pub mod rpc; +pub mod snapshot; +pub mod transactions; +pub mod websocket; + +use crate::Tracing; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// A durable Go counter agent registers, dispatches its methods, and keeps state +/// across invocations — the smoke test that proves the agent-sdk-go guest builds +/// and runs under the worker executor. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_counter_basic_invoke( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + + let agent_id = agent_id!("CounterAgent", "go-counter-1"); + executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + let v1 = executor + .invoke_and_await_agent(&component, &agent_id, "increment", data_value!()) + .await? + .into_typed::()?; + assert_eq!(v1, 1); + + let v2 = executor + .invoke_and_await_agent(&component, &agent_id, "add", data_value!(5i64)) + .await? + .into_typed::()?; + assert_eq!(v2, 6); + + let v3 = executor + .invoke_and_await_agent(&component, &agent_id, "value", data_value!()) + .await? + .into_typed::()?; + assert_eq!(v3, 6); + + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/promise.rs b/golem-worker-executor/tests/agent_sdk_go/promise.rs new file mode 100644 index 0000000000..92e868a7d7 --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/promise.rs @@ -0,0 +1,116 @@ +// 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. + +//! The Go SDK's promise wrapper: awaiting a promise durably SUSPENDS the worker +//! (it does not spin or return early), and completing it from outside resumes the +//! agent with the payload. Mirrors `api::promise`. + +use crate::Tracing; +use anyhow::anyhow; +use golem_common::model::{AgentStatus, OplogIndex, PromiseId}; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use std::time::Duration; +use test_r::{inherit_test_dep, test, timeout}; +use tracing::Instrument; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// The agent creates a promise and awaits it in a second invocation; the worker +/// must reach Suspended rather than returning, and completing the promise through +/// the executor API resumes it with the completed payload. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_promise_suspends_until_completed( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("PromiseAgent", "go-promise-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + // The agent returns the promise's oplog index, which addresses it for completion. + let oplog_idx = executor + .invoke_and_await_agent(&component, &agent_id, "create", data_value!()) + .await? + .into_typed::()?; + + let executor_clone = executor.clone(); + let component_clone = component.clone(); + let agent_id_clone = agent_id.clone(); + let mut fiber = tokio::spawn( + async move { + executor_clone + .invoke_and_await_agent( + &component_clone, + &agent_id_clone, + "await", + data_value!(oplog_idx), + ) + .await + } + .in_current_span(), + ); + + // The await must park the worker rather than complete. + tokio::select! { + result = &mut fiber => { + let invoke_result = result??; + return Err(anyhow!("await returned instead of suspending: {invoke_result:?}")); + } + status = executor.wait_for_status(&worker_id, AgentStatus::Suspended, Duration::from_secs(10)) => { + status?; + } + } + + executor + .complete_promise( + &PromiseId { + agent_id: worker_id.clone(), + oplog_idx: OplogIndex::from_u64(oplog_idx as u64), + }, + // The Go wrapper decodes the payload as JSON for a string T. + b"\"approved\"".to_vec(), + ) + .await?; + + let awaited = fiber.await??.into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(awaited, "approved"); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/retry.rs b/golem-worker-executor/tests/agent_sdk_go/retry.rs new file mode 100644 index 0000000000..af20eb570a --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/retry.rs @@ -0,0 +1,120 @@ +// 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. + +//! The Go SDK's retry DSL against a real failing endpoint: a policy that matches +//! on status code makes the host re-issue the request transparently, so the guest +//! only ever sees the eventual success. Mirrors +//! `agent_sdk_ts::sdk_policy::ts_http_status_retry_policy_retries_matching_status`. + +use crate::Tracing; +use axum::Router; +use axum::extract::Query; +use axum::http::StatusCode; +use axum::routing::get; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use serde::Deserialize; +use std::collections::HashMap; +use std::sync::Arc; +use std::sync::atomic::{AtomicU32, Ordering}; +use test_r::{inherit_test_dep, test, timeout}; +use tracing::Instrument; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// The endpoint answers 500 for the first two requests and 200 afterwards. Under +/// a `retry.StatusCode.OneOf(500)` policy the guest's single `http.Get` still +/// returns the success body, and the server saw exactly three live requests — +/// proving the retries were real and bounded. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_retry_policy_retries_matching_status( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + const FAIL_COUNT: u32 = 2; + let hits = Arc::new(AtomicU32::new(0)); + let hits_in_server = hits.clone(); + let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap(); + let port = listener.local_addr().unwrap().port(); + + #[derive(Deserialize)] + struct QueryParams { + payload: String, + } + + let server = tokio::spawn( + async move { + let route = Router::new().route( + "/callback", + get(move |query: Query| { + let hits = hits_in_server.clone(); + async move { + let n = hits.fetch_add(1, Ordering::AcqRel); + if n < FAIL_COUNT { + (StatusCode::INTERNAL_SERVER_ERROR, "boom".to_string()) + } else { + (StatusCode::OK, format!("ok-{}", query.payload)) + } + } + }), + ); + axum::serve(listener, route).await.unwrap(); + } + .in_current_span(), + ); + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("HttpAgent", "go-retry-1"); + let mut env = HashMap::new(); + env.insert("PORT".to_string(), port.to_string()); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), env, Vec::new()) + .await?; + + let body = executor + .invoke_and_await_agent(&component, &agent_id, "retry-callback", data_value!("x")) + .await? + .into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + server.abort(); + + assert_eq!(body, "ok-x"); + assert_eq!( + hits.load(Ordering::Acquire), + FAIL_COUNT + 1, + "the endpoint should have been hit once per attempt" + ); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/revert.rs b/golem-worker-executor/tests/agent_sdk_go/revert.rs new file mode 100644 index 0000000000..2d3bd85e1c --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/revert.rs @@ -0,0 +1,93 @@ +// 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. + +//! Reverting a Go agent's invocations rolls its state back: the oplog is the +//! source of truth for Go state too, so undoing recorded invocations rebuilds the +//! earlier value. + +use crate::Tracing; +use golem_common::model::worker::{RevertLastInvocations, RevertWorkerTarget}; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// After three recorded increments the counter reads 6; reverting the last two +/// invocations (the `add` and the `value` read) rebuilds the state as of the +/// first increment. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_revert_last_invocations( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("CounterAgent", "go-revert-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + executor + .invoke_and_await_agent(&component, &agent_id, "increment", data_value!()) + .await?; + executor + .invoke_and_await_agent(&component, &agent_id, "add", data_value!(5i64)) + .await?; + let before = executor + .invoke_and_await_agent(&component, &agent_id, "value", data_value!()) + .await? + .into_typed::()?; + + // Undo the `value` read and the `add`, leaving only the first increment. + executor + .revert( + &worker_id, + RevertWorkerTarget::RevertLastInvocations(RevertLastInvocations { + number_of_invocations: 2, + }), + ) + .await?; + + let after = executor + .invoke_and_await_agent(&component, &agent_id, "value", data_value!()) + .await? + .into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(before, 6); + assert_eq!(after, 1); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/rich_types.rs b/golem-worker-executor/tests/agent_sdk_go/rich_types.rs new file mode 100644 index 0000000000..46428a251d --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/rich_types.rs @@ -0,0 +1,99 @@ +// 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. + +//! Composite value types round-trip through the invocation wire for the Go SDK: +//! a list + optional argument in, and a list out. + +use crate::Tracing; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_rich_types_round_trip( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("RichAgent", "go-rich-1"); + executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + // list + Some(option) in. + let described = executor + .invoke_and_await_agent( + &component, + &agent_id, + "describe", + data_value!( + vec!["a".to_string(), "b".to_string()], + Some("hi".to_string()) + ), + ) + .await? + .into_typed::()?; + assert_eq!(described, "tags=a,b note=hi"); + + // empty list + None option. + let empty = executor + .invoke_and_await_agent( + &component, + &agent_id, + "describe", + data_value!(Vec::::new(), Option::::None), + ) + .await? + .into_typed::()?; + assert_eq!(empty, "tags= note=none"); + + // list out. + let repeated = executor + .invoke_and_await_agent( + &component, + &agent_id, + "repeat", + data_value!("x".to_string(), 3i64), + ) + .await? + .into_typed::>()?; + assert_eq!( + repeated, + vec!["x".to_string(), "x".to_string(), "x".to_string()] + ); + + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/rpc.rs b/golem-worker-executor/tests/agent_sdk_go/rpc.rs new file mode 100644 index 0000000000..2b14d9e0f0 --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/rpc.rs @@ -0,0 +1,80 @@ +// 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. + +//! Cross-agent RPC for the Go SDK: a caller agent invokes a durable ledger agent +//! synchronously (Call) and asynchronously (CallAsync + Future.Get), and the +//! ledger's accumulating state confirms the calls reached a real target. + +use crate::Tracing; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// Synchronous Call accumulates on the target (same region → same durable ledger +/// instance), and CallAsync + Future.Get works and routes by region. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_rpc_sync_and_async_calls( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("RpcAgent", "go-rpc-1"); + executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + // Two synchronous calls to the same region accumulate on that ledger instance. + let r1 = executor + .invoke_and_await_agent(&component, &agent_id, "call", data_value!("eu", 10i64)) + .await? + .into_typed::()?; + assert_eq!(r1, 10); + + let r2 = executor + .invoke_and_await_agent(&component, &agent_id, "call", data_value!("eu", 5i64)) + .await? + .into_typed::()?; + assert_eq!(r2, 15); + + // An async call to a different region hits a fresh ledger instance. + let r3 = executor + .invoke_and_await_agent(&component, &agent_id, "async", data_value!("us", 7i64)) + .await? + .into_typed::()?; + assert_eq!(r3, 7); + + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/schedule.rs b/golem-worker-executor/tests/agent_sdk_go/schedule.rs new file mode 100644 index 0000000000..199f6197ab --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/schedule.rs @@ -0,0 +1,132 @@ +// 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. + +//! Scheduled invocations from a Go guest: `MethodDef.Schedule` runs a cross-agent +//! call later without the caller waiting, and `ScheduledInvocation.Cancel` stops +//! one that has not started yet. + +use crate::Tracing; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use std::time::Duration; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// A scheduled increment runs on its own: the caller returns immediately and the +/// target counter moves once the scheduled time passes. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_scheduled_invocation_runs( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let scheduler_id = agent_id!("SchedulerAgent", "go-sched-1"); + let counter_id = agent_id!("CounterAgent", "go-sched-target-1"); + executor + .start_agent_with(&component.id, scheduler_id.clone(), HashMap::new(), Vec::new()) + .await?; + + executor + .invoke_and_await_agent( + &component, + &scheduler_id, + "bump", + data_value!("go-sched-target-1", 500i64), + ) + .await?; + + // The scheduled call runs on its own schedule, so poll for its effect. + let deadline = tokio::time::Instant::now() + Duration::from_secs(30); + let mut value = 0; + while tokio::time::Instant::now() < deadline { + value = executor + .invoke_and_await_agent(&component, &counter_id, "value", data_value!()) + .await? + .into_typed::()?; + if value >= 1 { + break; + } + tokio::time::sleep(Duration::from_millis(200)).await; + } + drop(executor); + + assert_eq!(value, 1, "the scheduled increment should have run"); + Ok(()) +} + +/// Cancelling a scheduled invocation before its time arrives prevents it: the +/// target counter never moves. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_scheduled_invocation_can_be_cancelled( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let scheduler_id = agent_id!("SchedulerAgent", "go-sched-2"); + let counter_id = agent_id!("CounterAgent", "go-sched-target-2"); + executor + .start_agent_with(&component.id, scheduler_id.clone(), HashMap::new(), Vec::new()) + .await?; + + executor + .invoke_and_await_agent( + &component, + &scheduler_id, + "bump-cancelled", + data_value!("go-sched-target-2", 500i64), + ) + .await?; + + // Well past the scheduled time: the cancelled invocation must not have run. + tokio::time::sleep(Duration::from_secs(3)).await; + let value = executor + .invoke_and_await_agent(&component, &counter_id, "value", data_value!()) + .await? + .into_typed::()?; + drop(executor); + + assert_eq!(value, 0, "the cancelled increment must not have run"); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/snapshot.rs b/golem-worker-executor/tests/agent_sdk_go/snapshot.rs new file mode 100644 index 0000000000..1ec2eeb554 --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/snapshot.rs @@ -0,0 +1,112 @@ +// 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. + +//! The Go SDK's custom snapshot support (`golem.Snapshotter`). The agent keeps its +//! counter in an UNEXPORTED field, which the SDK's default reflective snapshot +//! cannot see — so state surviving a snapshot-based recovery proves the SDK +//! actually called the type's Save/Load. + +use crate::Tracing; +use crate::durability::assert_snapshot_recovery_loaded; +use golem_common::model::oplog::{OplogIndex, PublicOplogEntry}; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor::services::golem_config::SnapshotPolicy; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, + start_with_snapshot_policy, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// With a snapshot taken every 2nd invocation, snapshots are recorded in the +/// oplog; after a restart the worker recovers from a snapshot and the counter — +/// held in an unexported field, so only reachable through the SDK's Save/Load — +/// is intact. +/// +/// IGNORED — enabling snapshotting on a Go agent makes the worker fail to start. +/// Observed: +/// - The worker fails with "Failed to instantiate primary executable" (a wasm +/// trap with no guest stderr), and no Snapshot oplog entries are recorded. +/// - Every other Go agent in the same component keeps working, and the Rust +/// control test `durability::automatic_snapshot_every_2nd_invocation` passes +/// under the same executor snapshot policy. +/// - It is NOT the Snapshotter path: replacing the custom Save/Load with a +/// plain exported-field state (the reflective JSON snapshot) fails +/// identically, and the failure is at worker CREATION, before any invocation. +/// - The SDK side that can be checked natively is correct: the policy reaches +/// the agent type (`TestSnapshotPolicyMapsToWit` covers all four variants), +/// `saveState`/`loadState` round-trip in unit tests, and the built component +/// does export `golem:api/save-snapshot` and `load-snapshot` (wasm-tools). +#[test] +#[ignore = "GOL-485: enabling snapshotting on a go agent breaks worker creation — go-guest replay divergence"] +#[tracing::instrument] +#[timeout("2m")] +async fn go_custom_snapshot_round_trips_unexported_state( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let policy = SnapshotPolicy::EveryNInvocation { count: 2 }; + let executor = start_with_snapshot_policy(deps, &context, policy.clone()).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("SnapAgent", "go-snapshot-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + for _ in 0..10 { + executor + .invoke_and_await_agent(&component, &agent_id, "bump", data_value!()) + .await?; + } + + let oplog = executor.get_oplog(&worker_id, OplogIndex::INITIAL).await?; + let snapshot_count = oplog + .iter() + .filter(|entry| matches!(&entry.entry, PublicOplogEntry::Snapshot(_))) + .count(); + + assert_eq!(snapshot_count, 5, "expected a snapshot every 2 invocations"); + + drop(executor); + let executor = start_with_snapshot_policy(deps, &context, policy).await?; + let mut events = executor.capture_output(&worker_id).await?; + + let value = executor + .invoke_and_await_agent(&component, &agent_id, "value", data_value!()) + .await? + .into_typed::()?; + assert_snapshot_recovery_loaded(&mut events).await; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(value, 10, "unexported counter must survive snapshot recovery"); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/transactions.rs b/golem-worker-executor/tests/agent_sdk_go/transactions.rs new file mode 100644 index 0000000000..12ab188aa4 --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/transactions.rs @@ -0,0 +1,122 @@ +// 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. + +//! The Go SDK's saga helpers: a committed transaction runs only its forward +//! steps, while a failing one rolls back — running the compensation of every step +//! that had already succeeded. The agent records each step and compensation as it +//! runs, so the recorded order is the assertion. + +use crate::Tracing; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// All steps succeed: the transaction commits and no compensation runs. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_transaction_commits( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("SagaAgent", "go-saga-ok"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + let outcome = executor + .invoke_and_await_agent(&component, &agent_id, "run", data_value!(false)) + .await? + .into_typed::()?; + let recorded = executor + .invoke_and_await_agent(&component, &agent_id, "log", data_value!()) + .await? + .into_typed::>()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(outcome, "committed"); + assert_eq!(recorded, vec!["charge".to_string(), "ship".to_string()]); + Ok(()) +} + +/// A later step fails: the transaction rolls back, running the compensation of +/// the step that had already succeeded (charge → refund). The failed step is not +/// compensated, since it never took effect. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_transaction_rolls_back_with_compensation( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("SagaAgent", "go-saga-fail"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + let outcome = executor + .invoke_and_await_agent(&component, &agent_id, "run", data_value!(true)) + .await? + .into_typed::()?; + let recorded = executor + .invoke_and_await_agent(&component, &agent_id, "log", data_value!()) + .await? + .into_typed::>()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + + assert_eq!(outcome, "rolled-back"); + assert_eq!( + recorded, + vec![ + "charge".to_string(), + "ship".to_string(), + "refund".to_string() + ] + ); + Ok(()) +} diff --git a/golem-worker-executor/tests/agent_sdk_go/websocket.rs b/golem-worker-executor/tests/agent_sdk_go/websocket.rs new file mode 100644 index 0000000000..b3e013053a --- /dev/null +++ b/golem-worker-executor/tests/agent_sdk_go/websocket.rs @@ -0,0 +1,100 @@ +// 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. + +//! The Go SDK's websocket wrapper drives a full client lifecycle — connect, send, +//! receive, close — against a real server. Mirrors `websocket::websocket_echo_ts`. + +use crate::Tracing; +use futures::{SinkExt, StreamExt}; +use golem_common::{agent_id, data_value}; +use golem_test_framework::dsl::TestDsl; +use golem_worker_executor_test_utils::{ + LastUniqueId, PrecompiledComponent, TestContext, WorkerExecutorTestDependencies, start, +}; +use std::collections::HashMap; +use test_r::{inherit_test_dep, test, timeout}; +use tokio::spawn; +use tracing::Instrument; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("agent_sdk_go")] + PrecompiledComponent +); + +/// A message sent through the wrapper comes back from the echo server, proving +/// connect/send/receive/close all work over the durable websocket transport. +#[test] +#[tracing::instrument] +#[timeout("2m")] +async fn go_websocket_echo( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, + #[tagged_as("agent_sdk_go")] agent_sdk_go: &PrecompiledComponent, +) -> anyhow::Result<()> { + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await?; + + let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap(); + let ws_port = listener.local_addr().unwrap().port(); + + let ws_server = spawn( + async move { + if let Ok((stream, _)) = listener.accept().await { + let ws_stream = tokio_tungstenite::accept_async(stream) + .await + .expect("WS handshake failed"); + let (mut write, mut read) = StreamExt::split(ws_stream); + while let Some(Ok(msg)) = StreamExt::next(&mut read).await { + if msg.is_close() { + break; + } + if msg.is_text() || msg.is_binary() { + SinkExt::send(&mut write, msg).await.ok(); + } + } + } + } + .in_current_span(), + ); + + let component = executor + .component_dep(&context.default_environment_id, agent_sdk_go) + .store() + .await?; + let agent_id = agent_id!("WsAgent", "go-ws-1"); + let worker_id = executor + .start_agent_with(&component.id, agent_id.clone(), HashMap::new(), Vec::new()) + .await?; + + let echoed = executor + .invoke_and_await_agent( + &component, + &agent_id, + "echo", + data_value!(format!("ws://localhost:{ws_port}"), "hello from go"), + ) + .await? + .into_typed::()?; + + executor.check_oplog_is_queryable(&worker_id).await?; + drop(executor); + ws_server.abort(); + + assert_eq!(echoed, "hello from go"); + Ok(()) +} diff --git a/golem-worker-executor/tests/http.rs b/golem-worker-executor/tests/http.rs index 30d2f9aa76..1c2b0fcce1 100644 --- a/golem-worker-executor/tests/http.rs +++ b/golem-worker-executor/tests/http.rs @@ -367,7 +367,7 @@ async fn http_client_using_reqwest_async_parallel( Ok(()) } -/// Regression test for G35/T48: concurrent HTTP sends interleave their durable +/// Regression test: concurrent HTTP sends interleave their durable /// records in the oplog in network/scheduling order, so an executor restart /// must replay them claim-based rather than positionally. The server holds /// every response of the first invocation until all 16 requests have arrived diff --git a/golem-worker-executor/tests/lib.rs b/golem-worker-executor/tests/lib.rs index 7deeb9258d..43ce000810 100644 --- a/golem-worker-executor/tests/lib.rs +++ b/golem-worker-executor/tests/lib.rs @@ -24,6 +24,7 @@ use std::sync::Once; use test_r::{sequential_suite, tag_suite, test_dep}; pub mod agent; +pub mod agent_sdk_go; pub mod agent_sdk_ts; pub mod api; pub mod blobstore; @@ -98,6 +99,7 @@ tag_suite!(websocket, group1); tag_suite!(rdbms, group1); tag_suite!(agent, group1); tag_suite!(agent_sdk_ts, group1); +tag_suite!(agent_sdk_go, group2); tag_suite!(hot_update, group2); tag_suite!(instance_layer, group2); @@ -266,3 +268,9 @@ test_component!( "golem_it_agent_sdk_ts", "golem-it:agent-sdk-ts" ); +test_component!( + agent_sdk_go, + "agent_sdk_go", + "golem_it_agent_sdk_go", + "golem-it:agent-sdk-go" +); 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..32b45c4bde --- /dev/null +++ b/sdks/go/golem/agentid.go @@ -0,0 +1,93 @@ +// 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 is an alias of [uuid.UUID]. +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]/[AgentDefinition.Get] — so the constructor parameters decode back into it. +// It calls the host, so it must run inside an invocation. +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. +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..35397ed371 --- /dev/null +++ b/sdks/go/golem/blobstore/blobstore.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 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. 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. Some backends report last-modified + // here rather than creation. + 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") + } + 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 JSON codec behind Store. +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..8b0777404b --- /dev/null +++ b/sdks/go/golem/client.go @@ -0,0 +1,195 @@ +// 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 +// [AgentDefinition.Get] 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 [AgentDefinition.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 [AgentDefinition.NewPhantom] to allocate a fresh one. +func WithPhantomID(id UUID) ClientOpt { + return func(o *clientOpts) { o.phantomID = witTypes.Some(uuidToWit(id)) } +} + +// Get 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). Such a failure is a programming or +// configuration error with no in-band recovery, so it panics rather than +// returning an error; the panic surfaces to the caller as 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 (a *AgentDefinition[Id, Cfg]) Get(id Id, opts ...ClientOpt) Client[Id] { + e := defs.agents[a.name] + if e == nil { + panic(fmt.Errorf("golem: Get: 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: Get %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: Get %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 [AgentDefinition.Get]). 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 (a *AgentDefinition[Id, Cfg]) NewPhantom(id Id) Client[Id] { + phantom := uuidFromWit(apiHost.GenerateIdempotencyKey()) + return a.Get(id, WithPhantomID(phantom)) +} + +// AgentErrorKind classifies an [AgentError]. +type AgentErrorKind uint8 + +const ( + // AgentInvalidInput means the input did not match the method's parameters. + AgentInvalidInput AgentErrorKind = iota + // AgentInvalidMethod means no such method exists on the agent. + AgentInvalidMethod + // AgentInvalidType means no such agent type exists. + AgentInvalidType + // AgentCustom means the agent failed (a returned error or a panic). + AgentCustom + // AgentUnknown is 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..15994a54f0 --- /dev/null +++ b/sdks/go/golem/codec.go @@ -0,0 +1,317 @@ +// 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 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 +} + +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 + }) +} diff --git a/sdks/go/golem/codec_aggregate.go b/sdks/go/golem/codec_aggregate.go new file mode 100644 index 0000000000..4b0615ac29 --- /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" +) + +// 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. +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 +// --------------------------------------------------------------------------- + +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..4007c3dd97 --- /dev/null +++ b/sdks/go/golem/codec_scalar.go @@ -0,0 +1,143 @@ +// 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" +) + +// 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 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 + } +} + +// optionOps abstracts the two Go spellings of an optional value, so *T and +// Option[T] share one codec and therefore produce identical schemas. +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()) + } +} + +// optionValueOps drives Option[T] through the same codec as *T, so the two +// spellings produce identical schemas and are interchangeable. +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>", Some(Some("x"))) + assertRoundTrip(t, "option> inner none", Some(None[string]())) + assertRoundTrip(t, "option> outer none", None[Option[string]]()) + assertRoundTrip(t, "**string via pointers", func() **string { + s := "deep" + p := &s + return &p + }()) + assertRoundTrip(t, "result, string>", + Ok[Option[Money], string](Some(Money{Amount: 1, Currency: "GBP"}))) + assertRoundTrip(t, "result>", + Ok[Result[int64, string], string](Err[int64, string]("inner"))) + assertRoundTrip(t, "list>>", []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>>", 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", Some(PaymentMethod(Cash{}))) + assertRoundTrip(t, "none of variant", None[PaymentMethod]()) + assertRoundTrip(t, "list", []PaymentMethod{ + Card{Number: "1", Expiry: StatusRevoked}, Cash{}, Transfer{IBAN: "X"}, + }) + assertRoundTrip(t, "result", + Ok[PaymentMethod, Status](Card{Number: "9", Expiry: StatusActive})) + assertRoundTrip(t, "err arm carrying an enum", + Err[PaymentMethod, Status](StatusRevoked)) + assertRoundTrip(t, "map", 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", Some(time.Unix(42, 0).UTC())) + assertRoundTrip(t, "list", []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..9a90415af0 --- /dev/null +++ b/sdks/go/golem/config.go @@ -0,0 +1,512 @@ +// 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. It 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, ShopConfig](spec) +// +// and read it from inside a method via [Config] (or, in the constructor, +// [InitContext.Config]): +// +// cfg := golem.Config(Shop, 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 golem.Config(Shop, 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; config-less agents +// created with [DefineAgent] never need to 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 running agent's config from within a method. def is the +// agent's [AgentDefinition] — its Cfg gives the config type — and scope is the +// running method's *[Context]: requiring a context means config can be read only +// from inside a running method, not from arbitrary code. +// +// The config is materialized once per worker and cached, 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 read failure has no in-band recovery, so it panics rather than +// returning an error; the panic surfaces as an agent-error. +func Config[Id any, S any, Cfg any](def *AgentDefinition[Id, Cfg], scope agentScope[S]) Cfg { + // def fixes Cfg; scope (the running method's *Context) is a compile-time gate. + _ = def + _ = scope + return materializeAgentConfig[Cfg]() +} + +// Config reads the agent's config from within its constructor. It behaves like +// [Config] and populates the same per-worker cache the methods reuse. +func (c *InitContext[Id, S, Cfg]) Config() Cfg { + return materializeAgentConfig[Cfg]() +} + +// cachedAgentConfig returns the worker's already-materialized config, if any — +// the cache-hit fast path with no host call. The host-backed miss path lives in +// materializeAgentConfig. +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; [Config] / [InitContext.Config] supply the host-backed reader. +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) + } + res := host.GetConfigValue(lf.path, d.graphForType(lf.typ)) + if res.IsErr() { + return reflect.Value{}, configValueErrorToGo(lf.path, res.Err()) + } + tree := res.Ok() + 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. The host call lives +// in the Secret's closure, reached only from a user's [Secret.Get]. +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]() + + handleRes := host.GetConfigValue(path, d.graphForType(reflect.TypeFor[Secret[T]]())) + if handleRes.IsErr() { + return zero, configValueErrorToGo(path, handleRes.Err()) + } + handle, err := extractSecretHandle(path, handleRes.Ok()) + 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 +} + +// configValueErrorToGo maps a host config-value error onto a Go error, keeping +// the case distinguishable rather than flattening it to a bare string. +func configValueErrorToGo(path []string, e host.ConfigValueError) error { + switch e.Tag() { + case host.ConfigValueErrorPermissionDenied: + return fmt.Errorf("golem/config %v: permission denied", path) + default: + return fmt.Errorf("golem/config %v: config value error (tag %d)", path, e.Tag()) + } +} + +// 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 [AgentDefinition.Get] +// (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..a8c5bf745d --- /dev/null +++ b/sdks/go/golem/config_test.go @@ -0,0 +1,320 @@ +// 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 +} + +var cfgPing = DefineMethod[cfgId, Unit, Unit]("ping") + +// cfgConfiguredAgent registers the "Cfg" agent's definition (with config type Cfg +// attached — declaration flattens the config surface, what these tests exercise) +// and a trivial implementation so discover() sees a complete agent. +func cfgConfiguredAgent[Cfg any](d *definitions) *AgentDefinition[cfgId, Cfg] { + def := defineAgentInto[cfgId, Cfg](d, Spec{Name: "Cfg"}) + impl := implementInto[cfgId, cfgState, Cfg](d, def, simpleNewState[cfgId, cfgState](func(cfgId) *cfgState { return &cfgState{} }), false) + Handle(impl, cfgPing, func(*Context[cfgState], Unit) Unit { return Unit{} }) + return def +} + +// 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..5e2c4c6bec --- /dev/null +++ b/sdks/go/golem/definition.go @@ -0,0 +1,220 @@ +// 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 typed calls (Get) + 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] + // An agent must be implemented, and have at least one method — otherwise a + // worker initialized as it would hit a nil constructor. Surface that as a + // definition error rather than a runtime panic. + if e.newState == nil { + errs = append(errs, definitionError{agent: name, detail: "agent defined but never implemented (call golem.Implement)"}) + } else if len(e.order) == 0 { + errs = append(errs, definitionError{agent: name, detail: "agent implemented but has no methods (call golem.Handle)"}) + } + 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..10117bef54 --- /dev/null +++ b/sdks/go/golem/definition_test.go @@ -0,0 +1,154 @@ +// 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 := (&AgentDefinition[struct{}, NoConfig]{name: "N"}).Name(); got != "N" { + t.Errorf("AgentDefinition.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, NoConfig](d, + Spec{Name: "Counter", HTTP: &Mount{Path: "/c/{name}"}}) + add := DefineMethod[Id, AddIn, int64]("add", HTTP(POST("/add?by={by}"))) + impl := implementInto[Id, St, NoConfig](d, a, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, 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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "Solo"}) + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, DefineMethod[Id, Unit, Unit]("ping"), func(*Context[St], Unit) Unit { return Unit{} }) + _, 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..b33f44fba3 --- /dev/null +++ b/sdks/go/golem/durability.go @@ -0,0 +1,213 @@ +// 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" + + apiHost "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_host" + apiOplog "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_oplog" + types "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_core_types" + durability "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_durability_durability" + witTypes "go.bytecodealliance.org/pkg/wit/types" +) + +// Durability helpers expose Golem's exactly-once execution knobs to a handler: +// atomic regions, 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 per worker, +// not per goroutine. +// Golem runs an agent single-threaded with cooperative task-switching only at +// await points (RPC, promise, sleep), so an atomic region or a +// 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) +} + +// 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) +} + +// --------------------------------------------------------------------------- +// Custom durability +// --------------------------------------------------------------------------- + +// DurableFunctionType selects how the executor commits and replays a custom +// durable operation. Use ReadLocal/WriteLocal/ReadRemote/WriteRemote for the +// common cases; the batched and transaction variants are for libraries that +// coordinate a group of writes. +type DurableFunctionType struct{ raw apiOplog.WrappedFunctionType } + +var ( + // ReadLocal reads local (worker-owned) state. + ReadLocal = DurableFunctionType{apiOplog.MakeWrappedFunctionTypeReadLocal()} + // WriteLocal writes local (worker-owned) state. + WriteLocal = DurableFunctionType{apiOplog.MakeWrappedFunctionTypeWriteLocal()} + // ReadRemote reads from an external system. + ReadRemote = DurableFunctionType{apiOplog.MakeWrappedFunctionTypeReadRemote()} + // WriteRemote writes to an external system (the usual choice for a side effect). + WriteRemote = DurableFunctionType{apiOplog.MakeWrappedFunctionTypeWriteRemote()} +) + +// WriteRemoteBatched marks a remote write that the executor may commit together +// with adjacent batched writes. Pass the oplog index that begins the batch to +// join an existing one; omit it to start a new batch. +func WriteRemoteBatched(begin ...uint64) DurableFunctionType { + return DurableFunctionType{apiOplog.MakeWrappedFunctionTypeWriteRemoteBatched(optionalOplogIndex(begin))} +} + +// WriteRemoteTransaction marks a remote write that participates in a durable +// transaction. Pass the oplog index that begins the transaction to join an +// existing one; omit it to start a new transaction. +func WriteRemoteTransaction(begin ...uint64) DurableFunctionType { + return DurableFunctionType{apiOplog.MakeWrappedFunctionTypeWriteRemoteTransaction(optionalOplogIndex(begin))} +} + +func optionalOplogIndex(begin []uint64) witTypes.Option[uint64] { + if len(begin) > 0 { + return witTypes.Some(begin[0]) + } + return witTypes.None[uint64]() +} + +// DurableSpec describes one custom durable operation: which function it stands +// for (Interface::Function, used as the persisted name) and its commit/replay +// policy. Set ForcedCommit to force an efficient oplog commit at the end of the +// operation. +type DurableSpec struct { + Interface string + Function string + Type DurableFunctionType + ForcedCommit bool +} + +// DurableOp wraps a non-durable side effect so it is recorded once and replayed +// from the oplog thereafter. It is the building block for authoring custom +// durable operations (the SDK's own keyvalue/blobstore/http wrappers are built +// the same way). +// +// On a live run it executes body, persists the encoded result, and returns it; +// on replay it returns the recorded result WITHOUT running body. request is +// recorded alongside the result so the oplog is self-describing; both request +// and result are encoded through the ordinary schema codec. +// +// Failure has two distinct channels: +// - Returning a value carries the outcome. If Out is a [Result], an err Result +// is a RECORDED durable failure — it is persisted and replayed like any other +// value, so the operation is not retried. +// - Panicking is a transient defect: the unfinished invocation is dropped and +// normal recovery re-executes body. Panic (or golem.Must) when the effect +// should be retried rather than recorded. +// +// There is no async variant: a blocking body already suspends the fiber at its +// await points, so one function covers both cases. +func DurableOp[In any, Out any](spec DurableSpec, request In, body func() Out) Out { + durability.ObserveFunctionCall(spec.Interface, spec.Function) + + name := spec.Function + if spec.Interface != "" { + name = spec.Interface + "::" + spec.Function + } + + req := encodeDurableValue(reflect.ValueOf(&request).Elem()) + invocation := durability.BeginCustomDurableInvocation(name, req, spec.Type.raw) + + if invocation.Tag() == durability.CustomDurableInvocationReplayed { + return decodeDurableValue[Out](name, invocation.Replayed().Response) + } + + // Live: run the body, persist its result, and finish. If body panics the + // invocation is left unfinished (dropped below) so recovery re-executes it. + live := invocation.Live() + committed := false + defer func() { + if !committed { + live.Drop() + } + }() + + out := body() + resp := encodeDurableValue(reflect.ValueOf(&out).Elem()) + durability.LiveCustomDurableInvocationFinish(live, resp, spec.ForcedCommit) + committed = true + return out +} + +// encodeDurableValue encodes a single value (not a parameter list) into a +// self-describing typed schema value. It panics on failure, matching the +// fail-loud durability surface. +func encodeDurableValue(v reflect.Value) types.TypedSchemaValue { + return types.TypedSchemaValue{ + Graph: defs.graphForType(v.Type()), + Value: encodeWith(defs.compile(v.Type()), v), + } +} + +// decodeDurableValue decodes a replayed response back into Out, panicking on a +// mismatch (a replay divergence is not recoverable in-band). +func decodeDurableValue[Out any](name string, tv types.TypedSchemaValue) Out { + typ := reflect.TypeFor[Out]() + dst := reflect.New(typ).Elem() + dec := decoder{nodes: tv.Value.ValueNodes} + if err := defs.compile(typ).decode(&dec, dst, tv.Value.Root); err != nil { + panic(fmt.Errorf("golem: durable %s: decoding replayed response: %w", name, err)) + } + return dst.Interface().(Out) +} diff --git a/sdks/go/golem/durability_test.go b/sdks/go/golem/durability_test.go new file mode 100644 index 0000000000..a3e23e4ccf --- /dev/null +++ b/sdks/go/golem/durability_test.go @@ -0,0 +1,61 @@ +// 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" + + apiOplog "github.com/golemcloud/golem/sdks/go/golem/internal/wit/golem_api_oplog" +) + +// TestDurableFunctionTypeMapping — each DurableFunctionType maps to the expected +// host WrappedFunctionType tag. This is the pure part of the custom-durability +// surface; DurableOp itself needs the host and is covered by the executor tests. +func TestDurableFunctionTypeMapping(t *testing.T) { + cases := []struct { + name string + ft DurableFunctionType + tag uint8 + }{ + {"ReadLocal", ReadLocal, apiOplog.WrappedFunctionTypeReadLocal}, + {"WriteLocal", WriteLocal, apiOplog.WrappedFunctionTypeWriteLocal}, + {"ReadRemote", ReadRemote, apiOplog.WrappedFunctionTypeReadRemote}, + {"WriteRemote", WriteRemote, apiOplog.WrappedFunctionTypeWriteRemote}, + {"WriteRemoteBatched", WriteRemoteBatched(), apiOplog.WrappedFunctionTypeWriteRemoteBatched}, + {"WriteRemoteTransaction", WriteRemoteTransaction(), apiOplog.WrappedFunctionTypeWriteRemoteTransaction}, + } + for _, c := range cases { + if got := c.ft.raw.Tag(); got != c.tag { + t.Fatalf("%s tag = %d, want %d", c.name, got, c.tag) + } + } +} + +// TestWriteRemoteBatchedBeginIndex — the optional begin index is carried when +// given and absent otherwise, for both batched and transaction variants. +func TestWriteRemoteBatchedBeginIndex(t *testing.T) { + if idx := WriteRemoteBatched().raw.WriteRemoteBatched(); idx.IsSome() { + t.Fatalf("WriteRemoteBatched() should carry no begin index, got %d", idx.Some()) + } + if idx := WriteRemoteBatched(42).raw.WriteRemoteBatched(); !idx.IsSome() || idx.Some() != 42 { + t.Fatalf("WriteRemoteBatched(42) begin index = %v, want Some(42)", idx) + } + if idx := WriteRemoteTransaction().raw.WriteRemoteTransaction(); idx.IsSome() { + t.Fatalf("WriteRemoteTransaction() should carry no begin index, got %d", idx.Some()) + } + if idx := WriteRemoteTransaction(7).raw.WriteRemoteTransaction(); !idx.IsSome() || idx.Some() != 7 { + t.Fatalf("WriteRemoteTransaction(7) begin index = %v, want Some(7)", idx) + } +} 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..d88cb60bf6 --- /dev/null +++ b/sdks/go/golem/golem.go @@ -0,0 +1,350 @@ +// 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's DEFINITION (its contract) and its IMPLEMENTATION (its behaviour) +// live in separate packages, so agents can call one another without Go import +// cycles. The definition is state-free and is what other agents import: +// +// // package counteragent — the definition (no state) +// type CounterId struct{ Name string } // constructor params; also the type-level identity +// type AddIn struct{ By int64 } +// +// var Agent = golem.DefineAgent[CounterId](golem.Spec{Name: "CounterAgent"}) +// var ( +// Add = golem.DefineMethod[CounterId, AddIn, int64]("add") +// Value = golem.DefineMethod[CounterId, golem.Unit, int64]("value") +// ) +// +// The implementation lives in its own package and owns the private state: +// +// // package counteragentimpl — the behaviour (state is unexported) +// type state struct{ count int64 } +// +// var counter = golem.Implement(counteragent.Agent, func(counteragent.CounterId) *state { return &state{} }) +// +// func init() { +// golem.Handle(counter, counteragent.Add, func(ctx *golem.Context[state], in counteragent.AddIn) int64 { +// ctx.State.count += in.By +// return ctx.State.count +// }) +// golem.Handle(counter, counteragent.Value, func(ctx *golem.Context[state], _ golem.Unit) int64 { +// return ctx.State.count +// }) +// } +// +// Another agent calls it through the definition — [AgentDefinition.Get] returns a +// client, and the method descriptor carries the call: +// +// client := counteragent.Agent.Get(counteragent.CounterId{Name: "c1"}) +// n := counteragent.Add.Call(client, counteragent.AddIn{By: 5}) +// +// 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. +// +// A component's main package blank-imports each implementation package (which +// registers its agent on import) and this package (which links the generated +// golem:agent/guest export glue into the component): +// +// import ( +// _ "example.com/app/counteragentimpl" +// _ "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]. +// [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 [Config] at compile time. +// +//nolint:unused // false positive: staticcheck's unused can't trace generic-interface satisfaction; 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 } + +// AgentDefinition is the state-free handle returned by [DefineAgent] / +// [DefineConfiguredAgent]. Id is the constructor parameter type, which doubles as +// the agent's type-level identity; Cfg is the agent's config struct ([NoConfig] +// for a config-less agent). It carries no state type: callers obtain a client +// with [AgentDefinition.Get] and never depend on how the target stores state. +// The behaviour (and the private state) is attached separately with [Implement]. +type AgentDefinition[Id any, Cfg any] struct{ name string } + +// Name returns the agent's wire-level type name. +func (a *AgentDefinition[Id, Cfg]) Name() string { return a.name } + +// AgentImpl is the state-bound implementation handle returned by [Implement] / +// [ImplementConfigured]. Register the agent's methods on it with [Handle]. Its S +// type parameter is the agent's private state type, introduced at [Implement]; it +// is used only inside the agent's implementation package (callers use the +// [AgentDefinition] instead). +type AgentImpl[Id any, S any, Cfg any] struct { + d *definitions + e *agentEntry +} + +// 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 +} + +// 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..f0e577a292 --- /dev/null +++ b/sdks/go/golem/golem_test.go @@ -0,0 +1,332 @@ +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]( + Spec{Name: "TestCounter", Description: "counter under test", Mode: Durable}, +) + +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() { + c := Implement(tCounter, func(id tCounterId) *tCounterState { return &tCounterState{} }) + Handle(c, tValue, func(ctx *Context[tCounterState], _ Unit) int64 { + return ctx.State.count + }) + Handle(c, tInc, func(ctx *Context[tCounterState], _ Unit) int64 { + ctx.State.count++ + return ctx.State.count + }) + Handle(c, tAdd, func(ctx *Context[tCounterState], in tAddIn) int64 { + ctx.State.count += in.By + return ctx.State.count + }) + Handle(c, tReset, Bind0Unit((*tCounterState).reset)) // method-expression binding + Handle(c, 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]( + Spec{Name: "TestEcho", Mode: Ephemeral}, +) + +var tSay = DefineMethod[tEchoId, tEchoIn, string]("say") + +func init() { + // tPay is declared below — package vars initialize before any init runs, so it + // is safe to reference here. + e := Implement(tEcho, func(id tEchoId) *tEchoState { return &tEchoState{prefix: id.Prefix} }) + Handle(e, tSay, func(ctx *Context[tEchoState], in tEchoIn) string { + return ctx.State.prefix + in.Msg + }) + Handle(e, tPay, func(*Context[tEchoState], Unit) PaymentMethod { + return Transfer{IBAN: "GB33"} + }) +} + +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. Bound into tEcho's Implement above. +var tPay = DefineMethod[tEchoId, Unit, PaymentMethod]("pay") + +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..cf46deb8d6 --- /dev/null +++ b/sdks/go/golem/http_mount.go @@ -0,0 +1,594 @@ +// 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. +// +// Route strings are not checked at compile time, so every binding rule is +// validated at registration and reported at discovery 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 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..c09e22a9d5 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_agent_common/wit_bindings.go @@ -0,0 +1,622 @@ +// 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.6.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:permissions@0.1.0 +// 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..961179ba81 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_agent_guest/wit_bindings.go @@ -0,0 +1,43 @@ +// 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.6.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:permissions@0.1.0 +// 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..7d163a5599 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_agent_host/wit_bindings.go @@ -0,0 +1,32802 @@ +// 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.6.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:permissions@0.1.0 +// 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 PermissionCard = golem_core_types.PermissionCard +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 ( + WebhookErrorPermissionDenied uint8 = 0 + WebhookErrorInternalError uint8 = 1 +) + +// 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. +type WebhookError struct { + tag uint8 + value any +} + +func (self WebhookError) Tag() uint8 { + return self.tag +} + +func (self WebhookError) InternalError() string { + if self.tag != WebhookErrorInternalError { + panic("tag mismatch") + } + return self.value.(string) +} + +func MakeWebhookErrorPermissionDenied() WebhookError { + return WebhookError{WebhookErrorPermissionDenied, nil} +} +func MakeWebhookErrorInternalError(value string) WebhookError { + return WebhookError{WebhookErrorInternalError, value} +} + +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 +} + +const ( + ConfigValueErrorPermissionDenied uint8 = 0 +) + +// 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. +type ConfigValueError struct { + tag uint8 + value any +} + +func (self ConfigValueError) Tag() uint8 { + return self.tag +} + +func MakeConfigValueErrorPermissionDenied() ConfigValueError { + return ConfigValueError{ConfigValueErrorPermissionDenied, nil} +} + +//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: + + variant162 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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: + + variant405 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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: + + variant162 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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: + + variant405 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*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: + + variant196 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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)))))) + + case 33: + + variant235 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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: + + variant160 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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)))))) + + case 33: + + variant199 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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: + + variant369 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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)))))) + + case 33: + + variant408 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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) witTypes.Result[string, WebhookError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 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) + var result witTypes.Result[string, WebhookError] + 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, WebhookError](value) + case 1: + var variant WebhookError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant = MakeWebhookErrorPermissionDenied() + + 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 = MakeWebhookErrorInternalError(value0) + + default: + panic("unreachable") + } + + result = witTypes.Err[string, WebhookError](variant) + default: + panic("unreachable") + } + result1 := result + return result1 + +} + +//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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*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") + } + slice193 := agentConfig + length195 := uint32(len(slice193)) + result194 := witRuntime.Allocate(pinner, uintptr(length195*(10*4)), 4) + for index, element := range slice193 { + base := unsafe.Add(result194, 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))) + slice153 := (((element).Value).Graph).TypeNodes + length155 := uint32(len(slice153)) + result154 := witRuntime.Allocate(pinner, uintptr(length155*(56+22*4)), 8) + for index, element := range slice153 { + base := unsafe.Add(result154, 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result141 int32 + if (payload).Polymorphic { + result141 = 1 + } else { + result141 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result141) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8142 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8142) + *(*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(utf8142))) + + default: + panic("unreachable") + } + slice144 := ((element).Metadata).Aliases + length146 := uint32(len(slice144)) + result145 := witRuntime.Allocate(pinner, uintptr(length146*(2*4)), 4) + for index, element := range slice144 { + base := unsafe.Add(result145, index*(2*4)) + utf8143 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8143) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8143))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length146) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result145))) + slice148 := ((element).Metadata).Examples + length150 := uint32(len(slice148)) + result149 := witRuntime.Allocate(pinner, uintptr(length150*(2*4)), 4) + for index, element := range slice148 { + base := unsafe.Add(result149, index*(2*4)) + utf8147 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8147) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8147))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length150) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result149))) + + 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)) + utf8151 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8151) + *(*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(utf8151))) + + 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)) + utf8152 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8152) + *(*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(utf8152))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(length155) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(result154))) + slice158 := (((element).Value).Graph).Defs + length160 := uint32(len(slice158)) + result159 := witRuntime.Allocate(pinner, uintptr(length160*(6*4)), 4) + for index, element := range slice158 { + base := unsafe.Add(result159, index*(6*4)) + utf8156 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8156) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8156))) + + 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)) + utf8157 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8157) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8157))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length160) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result159))) + *(*int32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = (((element).Value).Graph).Root + slice190 := (((element).Value).Value).ValueNodes + length192 := uint32(len(slice190)) + result191 := witRuntime.Allocate(pinner, uintptr(length192*(16+4*4)), 8) + for index, element := range slice190 { + base := unsafe.Add(result191, 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 result161 int32 + if payload { + result161 = 1 + } else { + result161 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result161) + + 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)) + utf8162 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8162) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8162))) + + case golem_core_types.SchemaValueNodeRecordValue: + payload := element.RecordValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13)) + slice163 := payload + length165 := uint32(len(slice163)) + result164 := witRuntime.Allocate(pinner, uintptr(length165*4), 4) + for index, element := range slice163 { + base := unsafe.Add(result164, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length165) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result164))) + + 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)) + slice167 := payload + length169 := uint32(len(slice167)) + result168 := witRuntime.Allocate(pinner, uintptr(length169*1), 1) + for index, element := range slice167 { + base := unsafe.Add(result168, index*1) + var result166 int32 + if element { + result166 = 1 + } else { + result166 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result166) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length169) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result168))) + + case golem_core_types.SchemaValueNodeTupleValue: + payload := element.TupleValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + slice170 := payload + length172 := uint32(len(slice170)) + result171 := witRuntime.Allocate(pinner, uintptr(length172*4), 4) + for index, element := range slice170 { + base := unsafe.Add(result171, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length172) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result171))) + + case golem_core_types.SchemaValueNodeListValue: + payload := element.ListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + slice173 := payload + length175 := uint32(len(slice173)) + result174 := witRuntime.Allocate(pinner, uintptr(length175*4), 4) + for index, element := range slice173 { + base := unsafe.Add(result174, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*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.SchemaValueNodeFixedListValue: + payload := element.FixedListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19)) + 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.SchemaValueNodeMapValue: + payload := element.MapValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20)) + slice179 := payload + length181 := uint32(len(slice179)) + result180 := witRuntime.Allocate(pinner, uintptr(length181*8), 4) + for index, element := range slice179 { + base := unsafe.Add(result180, 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(length181) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result180))) + + 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)) + utf8182 := unsafe.Pointer(unsafe.StringData((payload).Text)) + pinner.Pin(utf8182) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8182))) + + 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)) + utf8183 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8183) + *(*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(utf8183))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaValueNodeBinaryValue: + payload := element.BinaryValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24)) + data184 := unsafe.Pointer(unsafe.SliceData((payload).Bytes)) + pinner.Pin(data184) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data184))) + + 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)) + utf8185 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8185) + *(*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(utf8185))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaValueNodePathValue: + payload := element.PathValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25)) + 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.SchemaValueNodeUrlValue: + payload := element.UrlValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26)) + utf8187 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8187) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8187))) + + 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 + utf8188 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8188) + *(*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(utf8188))) + + case golem_core_types.SchemaValueNodeUnionValue: + payload := element.UnionValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30)) + utf8189 := unsafe.Pointer(unsafe.StringData((payload).Tag)) + pinner.Pin(utf8189) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8189))) + *(*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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length192) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result191))) + *(*int32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = (((element).Value).Value).Root + + } + + result196 := wasm_import_constructor_wasm_rpc(uintptr(utf8), uint32(len(agentTypeName)), uintptr(result26), length27, (constructor).Root, option, option28, option29, uintptr(result194), length195) + return WasmRpcFromOwnHandle(int32(uintptr(result196))) + +} + +//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 int32, arg7 int32, arg8 uintptr) + +func (self *WasmRpc) InvokeAndAwait(methodName string, input golem_core_types.SchemaValueTree, scopeCard witTypes.Option[*golem_core_types.PermissionCard]) 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + var option int32 + var option28 int32 + switch scopeCard.Tag() { + case witTypes.OptionNone: + + option = int32(0) + option28 = 0 + case witTypes.OptionSome: + payload := scopeCard.Some() + + option = int32(1) + option28 = (payload).Handle() + default: + panic("unreachable") + } + wasm_import_method_wasm_rpc_invoke_and_await((self).Handle(), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, option, option28, returnArea) + var result268 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)))) + value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + var option53 witTypes.Option[golem_core_types.SchemaValueTree] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4)))) { + case 0: + + option53 = witTypes.None[golem_core_types.SchemaValueTree]() + case 1: + result52 := 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 variant51 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant51 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant51 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant51 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant51 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant51 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant51 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant51 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant51 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant51 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant51 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant51 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant51 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value30 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant51 = golem_core_types.MakeSchemaValueNodeStringValue(value30) + + case 13: + result31 := 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) + + result31 = append(result31, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant51 = golem_core_types.MakeSchemaValueNodeRecordValue(result31) + + case 14: + var option32 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option32 = witTypes.None[int32]() + case 1: + + option32 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant51 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option32}) + + case 15: + + variant51 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result33 := 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) + + result33 = append(result33, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant51 = golem_core_types.MakeSchemaValueNodeFlagsValue(result33) + + case 17: + 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))) + } + + variant51 = golem_core_types.MakeSchemaValueNodeTupleValue(result34) + + case 18: + result35 := 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) + + result35 = append(result35, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant51 = golem_core_types.MakeSchemaValueNodeListValue(result35) + + case 19: + result36 := 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) + + result36 = append(result36, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant51 = golem_core_types.MakeSchemaValueNodeFixedListValue(result36) + + case 20: + result37 := 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) + + result37 = append(result37, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant51 = golem_core_types.MakeSchemaValueNodeMapValue(result37) + + case 21: + var option38 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option38 = witTypes.None[int32]() + case 1: + + option38 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant51 = golem_core_types.MakeSchemaValueNodeOptionValue(option38) + + case 22: + var variant golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option39 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option39 = witTypes.None[int32]() + case 1: + + option39 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant = golem_core_types.MakeResultValuePayloadOkValue(option39) + + case 1: + var option40 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option40 = witTypes.None[int32]() + case 1: + + option40 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant = golem_core_types.MakeResultValuePayloadErrValue(option40) + + default: + panic("unreachable") + } + + variant51 = golem_core_types.MakeSchemaValueNodeResultValue(variant) + + case 23: + value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option43 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option43 = witTypes.None[string]() + case 1: + value42 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option43 = witTypes.Some[string](value42) + default: + panic("unreachable") + } + + variant51 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value41, option43}) + + case 24: + value44 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option46 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option46 = witTypes.None[string]() + case 1: + value45 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option46 = witTypes.Some[string](value45) + default: + panic("unreachable") + } + + variant51 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value44, option46}) + + case 25: + value47 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant51 = golem_core_types.MakeSchemaValueNodePathValue(value47) + + case 26: + value48 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant51 = golem_core_types.MakeSchemaValueNodeUrlValue(value48) + + case 27: + + variant51 = 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: + + variant51 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value49 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant51 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value49}) + + case 30: + value50 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant51 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value50, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant51 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant51 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant51 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result52 = append(result52, variant51) + } + + option53 = witTypes.Some[golem_core_types.SchemaValueTree](golem_core_types.SchemaValueTree{result52, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (8 * 4)))}) + default: + panic("unreachable") + } + + result268 = witTypes.Ok[InvocationResultWithMetadata, RpcError](InvocationResultWithMetadata{InvocationMetadata{value, value29}, option53}) + case 1: + var variant267 RpcError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + value54 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant267 = MakeRpcErrorProtocolError(value54) + + case 1: + value55 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant267 = MakeRpcErrorDenied(value55) + + case 2: + value56 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant267 = MakeRpcErrorNotFound(value56) + + case 3: + value57 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant267 = MakeRpcErrorRemoteInternalError(value57) + + case 4: + var variant266 golem_agent_common.AgentError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) { + case 0: + value58 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant266 = golem_agent_common.MakeAgentErrorInvalidInput(value58) + + case 1: + value59 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant266 = golem_agent_common.MakeAgentErrorInvalidMethod(value59) + + case 2: + value60 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant266 = golem_agent_common.MakeAgentErrorInvalidType(value60) + + case 3: + value61 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant266 = golem_agent_common.MakeAgentErrorInvalidAgentId(value61) + + case 4: + result237 := 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 variant225 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant225 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant225 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option68 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option68 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option63 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant62 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant62 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant62 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option63 = witTypes.Some[golem_core_types.NumericBound](variant62) + default: + panic("unreachable") + } + var option65 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant64 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant64 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant64 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option65 = witTypes.Some[golem_core_types.NumericBound](variant64) + default: + panic("unreachable") + } + var option67 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option67 = witTypes.None[string]() + case 1: + value66 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option67 = witTypes.Some[string](value66) + default: + panic("unreachable") + } + + option68 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option63, option65, option67}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyS8Type(option68) + + case 3: + var option75 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option75 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option70 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant69 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant69 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant69 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option70 = witTypes.Some[golem_core_types.NumericBound](variant69) + default: + panic("unreachable") + } + var option72 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant71 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant71 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant71 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option72 = witTypes.Some[golem_core_types.NumericBound](variant71) + default: + panic("unreachable") + } + var option74 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option74 = witTypes.None[string]() + case 1: + value73 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option74 = witTypes.Some[string](value73) + default: + panic("unreachable") + } + + option75 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option70, option72, option74}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyS16Type(option75) + + case 4: + var option82 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option82 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option77 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant76 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant76 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant76 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option77 = witTypes.Some[golem_core_types.NumericBound](variant76) + default: + panic("unreachable") + } + var option79 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant78 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant78 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant78 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option79 = witTypes.Some[golem_core_types.NumericBound](variant78) + default: + panic("unreachable") + } + var option81 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option81 = witTypes.None[string]() + case 1: + value80 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option81 = witTypes.Some[string](value80) + default: + panic("unreachable") + } + + option82 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option77, option79, option81}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyS32Type(option82) + + case 5: + var option89 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option89 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option84 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant83 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant83 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant83 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option84 = witTypes.Some[golem_core_types.NumericBound](variant83) + default: + panic("unreachable") + } + var option86 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant85 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant85 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant85 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option86 = witTypes.Some[golem_core_types.NumericBound](variant85) + default: + panic("unreachable") + } + var option88 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option88 = witTypes.None[string]() + case 1: + value87 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option88 = witTypes.Some[string](value87) + default: + panic("unreachable") + } + + option89 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option84, option86, option88}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyS64Type(option89) + + case 6: + var option96 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option96 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option91 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant90 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant90 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant90 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option91 = witTypes.Some[golem_core_types.NumericBound](variant90) + default: + panic("unreachable") + } + var option93 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant92 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant92 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant92 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option93 = witTypes.Some[golem_core_types.NumericBound](variant92) + default: + panic("unreachable") + } + var option95 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option95 = witTypes.None[string]() + case 1: + value94 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option95 = witTypes.Some[string](value94) + default: + panic("unreachable") + } + + option96 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option91, option93, option95}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyU8Type(option96) + + case 7: + var option103 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option103 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option98 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant97 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant97 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant97 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option98 = witTypes.Some[golem_core_types.NumericBound](variant97) + default: + panic("unreachable") + } + var option100 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option100 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant99 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant99 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant99 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant99 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option100 = witTypes.Some[golem_core_types.NumericBound](variant99) + default: + panic("unreachable") + } + var option102 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option102 = witTypes.None[string]() + case 1: + value101 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option102 = witTypes.Some[string](value101) + default: + panic("unreachable") + } + + option103 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option98, option100, option102}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyU16Type(option103) + + case 8: + var option110 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option110 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option105 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant104 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant104 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant104 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option105 = witTypes.Some[golem_core_types.NumericBound](variant104) + default: + panic("unreachable") + } + var option107 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option107 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant106 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant106 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant106 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant106 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option107 = witTypes.Some[golem_core_types.NumericBound](variant106) + default: + panic("unreachable") + } + var option109 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option109 = witTypes.None[string]() + case 1: + value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option109 = witTypes.Some[string](value108) + default: + panic("unreachable") + } + + option110 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option105, option107, option109}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyU32Type(option110) + + case 9: + var option117 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option117 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option112 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant111 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant111 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant111 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option112 = witTypes.Some[golem_core_types.NumericBound](variant111) + default: + panic("unreachable") + } + var option114 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option114 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant113 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant113 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant113 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant113 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option114 = witTypes.Some[golem_core_types.NumericBound](variant113) + default: + panic("unreachable") + } + var option116 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option116 = witTypes.None[string]() + case 1: + value115 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option116 = witTypes.Some[string](value115) + default: + panic("unreachable") + } + + option117 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option112, option114, option116}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyU64Type(option117) + + case 10: + var option124 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option124 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option119 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant118 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant118 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant118 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option119 = witTypes.Some[golem_core_types.NumericBound](variant118) + default: + panic("unreachable") + } + var option121 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option121 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant120 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant120 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant120 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant120 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option121 = witTypes.Some[golem_core_types.NumericBound](variant120) + default: + panic("unreachable") + } + var option123 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option123 = witTypes.None[string]() + case 1: + value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option123 = witTypes.Some[string](value122) + default: + panic("unreachable") + } + + option124 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option119, option121, option123}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyF32Type(option124) + + case 11: + var option131 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option131 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option126 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant125 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant125 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant125 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option126 = witTypes.Some[golem_core_types.NumericBound](variant125) + default: + panic("unreachable") + } + var option128 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option128 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant127 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant127 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant127 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant127 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option128 = witTypes.Some[golem_core_types.NumericBound](variant127) + default: + panic("unreachable") + } + var option130 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option130 = witTypes.None[string]() + case 1: + value129 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option130 = witTypes.Some[string](value129) + default: + panic("unreachable") + } + + option131 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option126, option128, option130}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyF64Type(option131) + + case 12: + + variant225 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant225 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result144 := 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)) + value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option134 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option134 = witTypes.None[string]() + case 1: + value133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option134 = witTypes.Some[string](value133) + default: + panic("unreachable") + } + result136 := 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)) + 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) + } + + result138 := 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)) + 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) + } + + var option140 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option140 = witTypes.None[string]() + case 1: + value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option140 = witTypes.Some[string](value139) + default: + panic("unreachable") + } + var option143 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option143 = witTypes.None[golem_core_types.Role]() + case 1: + var variant142 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant142 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant142 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant142 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant142 = golem_core_types.MakeRoleOther(value141) + + default: + panic("unreachable") + } + + option143 = witTypes.Some[golem_core_types.Role](variant142) + default: + panic("unreachable") + } + + result144 = append(result144, golem_core_types.NamedFieldType{value132, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option134, result136, result138, option140, option143}}) + } + + variant225 = golem_core_types.MakeSchemaTypeBodyRecordType(result144) + + case 15: + result158 := 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)) + value145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option146 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option146 = witTypes.None[int32]() + case 1: + + option146 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option148 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option148 = witTypes.None[string]() + case 1: + value147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option148 = witTypes.Some[string](value147) + default: + panic("unreachable") + } + result150 := 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)) + 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) + } + + result152 := 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)) + 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) + } + + var option154 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option154 = witTypes.None[string]() + case 1: + value153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option154 = witTypes.Some[string](value153) + default: + panic("unreachable") + } + var option157 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option157 = witTypes.None[golem_core_types.Role]() + case 1: + var variant156 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant156 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant156 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant156 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant156 = golem_core_types.MakeRoleOther(value155) + + default: + panic("unreachable") + } + + option157 = witTypes.Some[golem_core_types.Role](variant156) + default: + panic("unreachable") + } + + result158 = append(result158, golem_core_types.VariantCaseType{value145, option146, golem_core_types.MetadataEnvelope{option148, result150, result152, option154, option157}}) + } + + variant225 = golem_core_types.MakeSchemaTypeBodyVariantType(result158) + + case 16: + 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) + } + + variant225 = golem_core_types.MakeSchemaTypeBodyEnumType(result160) + + case 17: + result162 := 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)) + value161 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result162 = append(result162, value161) + } + + variant225 = golem_core_types.MakeSchemaTypeBodyFlagsType(result162) + + case 18: + result163 := 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) + + result163 = append(result163, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant225 = golem_core_types.MakeSchemaTypeBodyTupleType(result163) + + case 19: + + variant225 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant225 = 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: + + variant225 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant225 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option164 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option164 = witTypes.None[int32]() + case 1: + + option164 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option165 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option165 = witTypes.None[int32]() + case 1: + + option165 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option164, option165}) + + case 24: + var option168 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option168 = witTypes.None[[]string]() + case 1: + result167 := 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)) + value166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result167 = append(result167, value166) + } + + option168 = witTypes.Some[[]string](result167) + default: + panic("unreachable") + } + var option169 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option169 = witTypes.None[uint32]() + case 1: + + option169 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option170 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option170 = witTypes.None[uint32]() + case 1: + + option170 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option172 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option172 = witTypes.None[string]() + case 1: + value171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option172 = witTypes.Some[string](value171) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option168, option169, option170, option172}) + + case 25: + var option175 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option175 = witTypes.None[[]string]() + case 1: + result174 := 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)) + value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result174 = append(result174, value173) + } + + option175 = witTypes.Some[[]string](result174) + default: + panic("unreachable") + } + var option176 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option176 = witTypes.None[uint32]() + case 1: + + option176 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option177 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option177 = witTypes.None[uint32]() + case 1: + + option177 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option175, option176, option177}) + + case 26: + var option180 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option180 = witTypes.None[[]string]() + case 1: + result179 := 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)) + 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) + } + + option180 = witTypes.Some[[]string](result179) + default: + panic("unreachable") + } + var option183 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option183 = witTypes.None[[]string]() + case 1: + result182 := 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)) + value181 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result182 = append(result182, value181) + } + + option183 = witTypes.Some[[]string](result182) + default: + panic("unreachable") + } + + variant225 = 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)))), option180, option183}) + + case 27: + var option186 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option186 = witTypes.None[[]string]() + case 1: + result185 := 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)) + 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) + } + + option186 = witTypes.Some[[]string](result185) + default: + panic("unreachable") + } + var option189 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option189 = witTypes.None[[]string]() + case 1: + result188 := 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)) + value187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result188 = append(result188, value187) + } + + option189 = witTypes.Some[[]string](result188) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option186, option189}) + + case 28: + + variant225 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant225 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result192 := 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)) + value191 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result192 = append(result192, value191) + } + + var option194 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option194 = 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))), value193}) + default: + panic("unreachable") + } + var option196 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option196 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option196 = 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))), value195}) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value190, result192, option194, option196}) + + case 31: + result218 := 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)) + value197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant206 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant206 = golem_core_types.MakeDiscriminatorRulePrefix(value198) + + case 1: + value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant206 = golem_core_types.MakeDiscriminatorRuleSuffix(value199) + + case 2: + value200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant206 = golem_core_types.MakeDiscriminatorRuleContains(value200) + + case 3: + value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant206 = golem_core_types.MakeDiscriminatorRuleRegex(value201) + + case 4: + value202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option204 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option204 = witTypes.None[string]() + case 1: + value203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option204 = witTypes.Some[string](value203) + default: + panic("unreachable") + } + + variant206 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value202, option204}) + + case 5: + value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant206 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value205) + + default: + panic("unreachable") + } + var option208 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option208 = witTypes.None[string]() + case 1: + value207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option208 = witTypes.Some[string](value207) + default: + panic("unreachable") + } + result210 := 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)) + 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) + } + + result212 := 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)) + value211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result212 = append(result212, value211) + } + + var option214 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option214 = witTypes.None[string]() + case 1: + value213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option214 = witTypes.Some[string](value213) + default: + panic("unreachable") + } + var option217 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option217 = witTypes.None[golem_core_types.Role]() + case 1: + var variant216 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant216 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant216 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant216 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant216 = golem_core_types.MakeRoleOther(value215) + + default: + panic("unreachable") + } + + option217 = witTypes.Some[golem_core_types.Role](variant216) + default: + panic("unreachable") + } + + result218 = append(result218, golem_core_types.UnionBranch{value197, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant206, golem_core_types.MetadataEnvelope{option208, result210, result212, option214, option217}}) + } + + variant225 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result218}) + + case 32: + var option220 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option220 = witTypes.None[string]() + case 1: + value219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option220 = witTypes.Some[string](value219) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option220}) + + case 33: + var option222 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option222 = witTypes.None[string]() + case 1: + value221 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option222 = witTypes.Some[string](value221) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option222}) + + case 34: + + variant225 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyFutureType(option223) + + case 36: + var option224 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option224 = witTypes.None[int32]() + case 1: + + option224 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant225 = golem_core_types.MakeSchemaTypeBodyStreamType(option224) + + default: + panic("unreachable") + } + var option227 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option227 = witTypes.None[string]() + case 1: + value226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option227 = witTypes.Some[string](value226) + default: + panic("unreachable") + } + result229 := 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)) + 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) + } + + result231 := 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)) + value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result231 = append(result231, value230) + } + + var option233 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option233 = witTypes.None[string]() + case 1: + value232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option233 = witTypes.Some[string](value232) + default: + panic("unreachable") + } + var option236 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option236 = witTypes.None[golem_core_types.Role]() + case 1: + var variant235 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant235 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant235 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant235 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value234 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant235 = golem_core_types.MakeRoleOther(value234) + + default: + panic("unreachable") + } + + option236 = witTypes.Some[golem_core_types.Role](variant235) + default: + panic("unreachable") + } + + result237 = append(result237, golem_core_types.SchemaTypeNode{variant225, golem_core_types.MetadataEnvelope{option227, result229, result231, option233, option236}}) + } + + result241 := 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)) + value238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option240 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option240 = witTypes.None[string]() + case 1: + value239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option240 = witTypes.Some[string](value239) + default: + panic("unreachable") + } + + result241 = append(result241, golem_core_types.SchemaTypeDef{value238, option240, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result265 := 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 variant264 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant264 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant264 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant264 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant264 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant264 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant264 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant264 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant264 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant264 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant264 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant264 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant264 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value242 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant264 = golem_core_types.MakeSchemaValueNodeStringValue(value242) + + case 13: + result243 := 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) + + result243 = append(result243, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant264 = golem_core_types.MakeSchemaValueNodeRecordValue(result243) + + case 14: + var option244 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option244 = witTypes.None[int32]() + case 1: + + option244 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant264 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option244}) + + case 15: + + variant264 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result245 := 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) + + result245 = append(result245, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant264 = golem_core_types.MakeSchemaValueNodeFlagsValue(result245) + + case 17: + 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))) + } + + variant264 = golem_core_types.MakeSchemaValueNodeTupleValue(result246) + + case 18: + result247 := 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) + + result247 = append(result247, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant264 = golem_core_types.MakeSchemaValueNodeListValue(result247) + + case 19: + result248 := 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) + + result248 = append(result248, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant264 = golem_core_types.MakeSchemaValueNodeFixedListValue(result248) + + case 20: + result249 := 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) + + result249 = append(result249, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant264 = golem_core_types.MakeSchemaValueNodeMapValue(result249) + + case 21: + var option250 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option250 = witTypes.None[int32]() + case 1: + + option250 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant264 = golem_core_types.MakeSchemaValueNodeOptionValue(option250) + + case 22: + var variant253 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option251 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option251 = witTypes.None[int32]() + case 1: + + option251 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant253 = golem_core_types.MakeResultValuePayloadOkValue(option251) + + case 1: + var option252 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option252 = witTypes.None[int32]() + case 1: + + option252 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant253 = golem_core_types.MakeResultValuePayloadErrValue(option252) + + default: + panic("unreachable") + } + + variant264 = golem_core_types.MakeSchemaValueNodeResultValue(variant253) + + case 23: + value254 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option256 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option256 = witTypes.None[string]() + case 1: + value255 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option256 = witTypes.Some[string](value255) + default: + panic("unreachable") + } + + variant264 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value254, option256}) + + case 24: + value257 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option259 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option259 = witTypes.None[string]() + case 1: + value258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option259 = witTypes.Some[string](value258) + default: + panic("unreachable") + } + + variant264 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value257, option259}) + + case 25: + value260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant264 = golem_core_types.MakeSchemaValueNodePathValue(value260) + + case 26: + value261 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant264 = golem_core_types.MakeSchemaValueNodeUrlValue(value261) + + case 27: + + variant264 = 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: + + variant264 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value262 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant264 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value262}) + + case 30: + value263 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant264 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value263, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant264 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant264 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant264 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result265 = append(result265, variant264) + } + + variant266 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result237, result241, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))}, golem_core_types.SchemaValueTree{result265, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4)))}}) + + default: + panic("unreachable") + } + + variant267 = MakeRpcErrorRemoteAgentError(variant266) + + default: + panic("unreachable") + } + + result268 = witTypes.Err[InvocationResultWithMetadata, RpcError](variant267) + default: + panic("unreachable") + } + result269 := result268 + return result269 + +} + +//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 int32, arg7 int32, arg8 uintptr) + +func (self *WasmRpc) Invoke(methodName string, input golem_core_types.SchemaValueTree, scopeCard witTypes.Option[*golem_core_types.PermissionCard]) 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + var option int32 + var option28 int32 + switch scopeCard.Tag() { + case witTypes.OptionNone: + + option = int32(0) + option28 = 0 + case witTypes.OptionSome: + payload := scopeCard.Some() + + option = int32(1) + option28 = (payload).Handle() + default: + panic("unreachable") + } + wasm_import_method_wasm_rpc_invoke((self).Handle(), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, option, option28, returnArea) + var result243 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)))) + value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + result243 = witTypes.Ok[InvocationMetadata, RpcError](InvocationMetadata{value, value29}) + case 1: + var variant242 RpcError + 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)))) + + variant242 = MakeRpcErrorProtocolError(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)))) + + variant242 = MakeRpcErrorDenied(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)))) + + variant242 = MakeRpcErrorNotFound(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)))) + + variant242 = MakeRpcErrorRemoteInternalError(value33) + + case 4: + var variant241 golem_agent_common.AgentError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) { + case 0: + value34 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidInput(value34) + + case 1: + value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidMethod(value35) + + case 2: + value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidType(value36) + + case 3: + value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidAgentId(value37) + + case 4: + result212 := 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 variant200 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant200 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant200 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option43 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option43 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option38 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option38 = 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") + } + + option38 = witTypes.Some[golem_core_types.NumericBound](variant) + default: + panic("unreachable") + } + var option40 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option40 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant39 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant39 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant39 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant39 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option40 = witTypes.Some[golem_core_types.NumericBound](variant39) + default: + panic("unreachable") + } + var option42 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option42 = witTypes.None[string]() + case 1: + value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option42 = witTypes.Some[string](value41) + default: + panic("unreachable") + } + + option43 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option38, option40, option42}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS8Type(option43) + + case 3: + var option50 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option50 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option45 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant44 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant44 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant44 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option45 = witTypes.Some[golem_core_types.NumericBound](variant44) + default: + panic("unreachable") + } + var option47 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option47 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant46 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant46 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant46 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant46 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option47 = witTypes.Some[golem_core_types.NumericBound](variant46) + default: + panic("unreachable") + } + var option49 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option49 = witTypes.None[string]() + case 1: + value48 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option49 = witTypes.Some[string](value48) + default: + panic("unreachable") + } + + option50 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option45, option47, option49}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS16Type(option50) + + case 4: + var option57 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option57 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option52 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant51 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant51 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant51 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option52 = witTypes.Some[golem_core_types.NumericBound](variant51) + default: + panic("unreachable") + } + var option54 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option54 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant53 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant53 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant53 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant53 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option54 = witTypes.Some[golem_core_types.NumericBound](variant53) + default: + panic("unreachable") + } + var option56 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option56 = witTypes.None[string]() + case 1: + value55 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option56 = witTypes.Some[string](value55) + default: + panic("unreachable") + } + + option57 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option52, option54, option56}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS32Type(option57) + + case 5: + var option64 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option64 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option59 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant58 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant58 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant58 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option59 = witTypes.Some[golem_core_types.NumericBound](variant58) + default: + panic("unreachable") + } + var option61 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant60 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant60 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant60 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option61 = witTypes.Some[golem_core_types.NumericBound](variant60) + default: + panic("unreachable") + } + var option63 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option63 = witTypes.None[string]() + case 1: + value62 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option63 = witTypes.Some[string](value62) + default: + panic("unreachable") + } + + option64 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option59, option61, option63}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS64Type(option64) + + case 6: + var option71 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option71 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option66 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant65 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant65 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant65 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option66 = witTypes.Some[golem_core_types.NumericBound](variant65) + default: + panic("unreachable") + } + var option68 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant67 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant67 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant67 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option68 = witTypes.Some[golem_core_types.NumericBound](variant67) + default: + panic("unreachable") + } + var option70 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option70 = witTypes.None[string]() + case 1: + value69 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option70 = witTypes.Some[string](value69) + default: + panic("unreachable") + } + + option71 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option66, option68, option70}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU8Type(option71) + + case 7: + var option78 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option78 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option73 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant72 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant72 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant72 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option73 = witTypes.Some[golem_core_types.NumericBound](variant72) + default: + panic("unreachable") + } + var option75 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant74 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant74 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant74 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option75 = witTypes.Some[golem_core_types.NumericBound](variant74) + default: + panic("unreachable") + } + var option77 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option77 = witTypes.None[string]() + case 1: + value76 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option77 = witTypes.Some[string](value76) + default: + panic("unreachable") + } + + option78 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option73, option75, option77}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU16Type(option78) + + case 8: + var option85 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option85 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option80 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant79 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant79 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant79 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option80 = witTypes.Some[golem_core_types.NumericBound](variant79) + default: + panic("unreachable") + } + var option82 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant81 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant81 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant81 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option82 = witTypes.Some[golem_core_types.NumericBound](variant81) + default: + panic("unreachable") + } + var option84 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option84 = witTypes.None[string]() + case 1: + value83 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option84 = witTypes.Some[string](value83) + default: + panic("unreachable") + } + + option85 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option80, option82, option84}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU32Type(option85) + + case 9: + var option92 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option92 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option87 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant86 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant86 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant86 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option87 = witTypes.Some[golem_core_types.NumericBound](variant86) + default: + panic("unreachable") + } + var option89 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant88 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant88 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant88 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option89 = witTypes.Some[golem_core_types.NumericBound](variant88) + default: + panic("unreachable") + } + var option91 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option91 = witTypes.None[string]() + case 1: + value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option91 = witTypes.Some[string](value90) + default: + panic("unreachable") + } + + option92 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option87, option89, option91}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU64Type(option92) + + case 10: + var option99 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option99 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option94 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant93 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant93 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant93 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option94 = witTypes.Some[golem_core_types.NumericBound](variant93) + default: + panic("unreachable") + } + var option96 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant95 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant95 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant95 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option96 = witTypes.Some[golem_core_types.NumericBound](variant95) + default: + panic("unreachable") + } + var option98 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option98 = witTypes.None[string]() + case 1: + value97 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option98 = witTypes.Some[string](value97) + default: + panic("unreachable") + } + + option99 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option94, option96, option98}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyF32Type(option99) + + case 11: + var option106 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option106 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option101 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant100 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant100 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant100 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option101 = witTypes.Some[golem_core_types.NumericBound](variant100) + default: + panic("unreachable") + } + var option103 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option103 = witTypes.Some[golem_core_types.NumericBound](variant102) + default: + panic("unreachable") + } + var option105 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option105 = witTypes.None[string]() + case 1: + value104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option105 = witTypes.Some[string](value104) + default: + panic("unreachable") + } + + option106 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option101, option103, option105}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyF64Type(option106) + + case 12: + + variant200 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant200 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result119 := 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)) + value107 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option109 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option109 = witTypes.None[string]() + case 1: + value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option109 = witTypes.Some[string](value108) + default: + panic("unreachable") + } + result111 := 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)) + 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) + } + + result113 := 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)) + value112 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result113 = append(result113, value112) + } + + var option115 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option115 = witTypes.None[string]() + case 1: + value114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option115 = witTypes.Some[string](value114) + default: + panic("unreachable") + } + var option118 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option118 = witTypes.None[golem_core_types.Role]() + case 1: + var variant117 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant117 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant117 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant117 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant117 = golem_core_types.MakeRoleOther(value116) + + default: + panic("unreachable") + } + + option118 = witTypes.Some[golem_core_types.Role](variant117) + default: + panic("unreachable") + } + + result119 = append(result119, golem_core_types.NamedFieldType{value107, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option109, result111, result113, option115, option118}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyRecordType(result119) + + case 15: + result133 := 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)) + value120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option121 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option121 = witTypes.None[int32]() + case 1: + + option121 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option123 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option123 = witTypes.None[string]() + case 1: + value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option123 = witTypes.Some[string](value122) + default: + panic("unreachable") + } + result125 := 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)) + 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) + } + + result127 := 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)) + 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[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option129 = witTypes.None[string]() + case 1: + value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option129 = witTypes.Some[string](value128) + default: + panic("unreachable") + } + var option132 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option132 = witTypes.None[golem_core_types.Role]() + case 1: + var variant131 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant131 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant131 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant131 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant131 = golem_core_types.MakeRoleOther(value130) + + default: + panic("unreachable") + } + + option132 = witTypes.Some[golem_core_types.Role](variant131) + default: + panic("unreachable") + } + + result133 = append(result133, golem_core_types.VariantCaseType{value120, option121, golem_core_types.MetadataEnvelope{option123, result125, result127, option129, option132}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyVariantType(result133) + + case 16: + 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) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyEnumType(result135) + + case 17: + result137 := 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)) + value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result137 = append(result137, value136) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyFlagsType(result137) + + case 18: + result138 := 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) + + result138 = append(result138, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyTupleType(result138) + + case 19: + + variant200 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant200 = 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: + + variant200 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant200 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option139 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option139 = witTypes.None[int32]() + case 1: + + option139 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option140 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option140 = witTypes.None[int32]() + case 1: + + option140 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option139, option140}) + + case 24: + var option143 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option143 = witTypes.None[[]string]() + case 1: + result142 := 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)) + value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result142 = append(result142, value141) + } + + option143 = witTypes.Some[[]string](result142) + default: + panic("unreachable") + } + var option144 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option144 = witTypes.None[uint32]() + case 1: + + option144 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option145 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option145 = witTypes.None[uint32]() + case 1: + + option145 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option147 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option147 = witTypes.None[string]() + case 1: + value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option147 = witTypes.Some[string](value146) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option143, option144, option145, option147}) + + case 25: + var option150 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option150 = witTypes.None[[]string]() + case 1: + result149 := 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)) + 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") + } + var option151 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option151 = witTypes.None[uint32]() + case 1: + + option151 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option152 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option152 = witTypes.None[uint32]() + case 1: + + option152 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option150, option151, option152}) + + case 26: + var option155 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option155 = witTypes.None[[]string]() + case 1: + result154 := 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)) + value153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result154 = append(result154, value153) + } + + option155 = witTypes.Some[[]string](result154) + default: + panic("unreachable") + } + var option158 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option158 = witTypes.None[[]string]() + case 1: + result157 := 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)) + value156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result157 = append(result157, value156) + } + + option158 = witTypes.Some[[]string](result157) + default: + panic("unreachable") + } + + variant200 = 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)))), option155, option158}) + + case 27: + var option161 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option161 = witTypes.None[[]string]() + case 1: + result160 := 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)) + 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) + } + + option161 = witTypes.Some[[]string](result160) + default: + panic("unreachable") + } + var option164 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option164 = witTypes.None[[]string]() + case 1: + result163 := 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)) + 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) + } + + option164 = witTypes.Some[[]string](result163) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option161, option164}) + + case 28: + + variant200 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant200 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result167 := 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)) + value166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result167 = append(result167, value166) + } + + var option169 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option169 = 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))), value168}) + default: + panic("unreachable") + } + var option171 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option171 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option171 = 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))), value170}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value165, result167, option169, option171}) + + case 31: + result193 := 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)) + value172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant181 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRulePrefix(value173) + + case 1: + value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleSuffix(value174) + + case 2: + value175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleContains(value175) + + case 3: + value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleRegex(value176) + + case 4: + value177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option179 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option179 = witTypes.None[string]() + case 1: + value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option179 = witTypes.Some[string](value178) + default: + panic("unreachable") + } + + variant181 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value177, option179}) + + case 5: + value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value180) + + default: + panic("unreachable") + } + var option183 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option183 = witTypes.None[string]() + case 1: + value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option183 = witTypes.Some[string](value182) + default: + panic("unreachable") + } + result185 := 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)) + 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) + } + + result187 := 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)) + value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result187 = append(result187, value186) + } + + var option189 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option189 = witTypes.None[string]() + case 1: + value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option189 = witTypes.Some[string](value188) + default: + panic("unreachable") + } + var option192 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option192 = witTypes.None[golem_core_types.Role]() + case 1: + var variant191 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant191 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant191 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant191 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant191 = golem_core_types.MakeRoleOther(value190) + + default: + panic("unreachable") + } + + option192 = witTypes.Some[golem_core_types.Role](variant191) + default: + panic("unreachable") + } + + result193 = append(result193, golem_core_types.UnionBranch{value172, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant181, golem_core_types.MetadataEnvelope{option183, result185, result187, option189, option192}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result193}) + + case 32: + var option195 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option195 = witTypes.None[string]() + case 1: + value194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option195 = witTypes.Some[string](value194) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option195}) + + case 33: + var option197 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option197 = witTypes.None[string]() + case 1: + value196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option197 = witTypes.Some[string](value196) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option197}) + + case 34: + + variant200 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyFutureType(option198) + + case 36: + var option199 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option199 = witTypes.None[int32]() + case 1: + + option199 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyStreamType(option199) + + default: + panic("unreachable") + } + var option202 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option202 = witTypes.None[string]() + case 1: + value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option202 = witTypes.Some[string](value201) + default: + panic("unreachable") + } + result204 := 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)) + 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) + } + + result206 := 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)) + value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result206 = append(result206, value205) + } + + var option208 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option208 = witTypes.None[string]() + case 1: + value207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option208 = witTypes.Some[string](value207) + default: + panic("unreachable") + } + var option211 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option211 = witTypes.None[golem_core_types.Role]() + case 1: + var variant210 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant210 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant210 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant210 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant210 = golem_core_types.MakeRoleOther(value209) + + default: + panic("unreachable") + } + + option211 = witTypes.Some[golem_core_types.Role](variant210) + default: + panic("unreachable") + } + + result212 = append(result212, golem_core_types.SchemaTypeNode{variant200, golem_core_types.MetadataEnvelope{option202, result204, result206, option208, option211}}) + } + + result216 := 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)) + value213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option215 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option215 = witTypes.None[string]() + case 1: + value214 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option215 = witTypes.Some[string](value214) + default: + panic("unreachable") + } + + result216 = append(result216, golem_core_types.SchemaTypeDef{value213, option215, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result240 := 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 variant239 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant239 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant239 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant239 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant239 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant239 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant239 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant239 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant239 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant239 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant239 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant239 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant239 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeStringValue(value217) + + case 13: + 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))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeRecordValue(result218) + + case 14: + 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") + } + + variant239 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option219}) + + case 15: + + variant239 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result220 := 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) + + result220 = append(result220, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant239 = golem_core_types.MakeSchemaValueNodeFlagsValue(result220) + + case 17: + 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))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeTupleValue(result221) + + case 18: + result222 := 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) + + result222 = append(result222, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeListValue(result222) + + case 19: + result223 := 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) + + result223 = append(result223, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeFixedListValue(result223) + + case 20: + result224 := 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) + + result224 = append(result224, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant239 = golem_core_types.MakeSchemaValueNodeMapValue(result224) + + case 21: + var option225 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option225 = witTypes.None[int32]() + case 1: + + option225 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeOptionValue(option225) + + case 22: + var variant228 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option226 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option226 = witTypes.None[int32]() + case 1: + + option226 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant228 = golem_core_types.MakeResultValuePayloadOkValue(option226) + + case 1: + var option227 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option227 = witTypes.None[int32]() + case 1: + + option227 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant228 = golem_core_types.MakeResultValuePayloadErrValue(option227) + + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeResultValue(variant228) + + case 23: + value229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option231 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option231 = witTypes.None[string]() + case 1: + value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option231 = witTypes.Some[string](value230) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value229, option231}) + + case 24: + value232 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option234 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option234 = witTypes.None[string]() + case 1: + value233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option234 = witTypes.Some[string](value233) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value232, option234}) + + case 25: + value235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodePathValue(value235) + + case 26: + value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeUrlValue(value236) + + case 27: + + variant239 = 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: + + variant239 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value237}) + + case 30: + value238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value238, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant239 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant239 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant239 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result240 = append(result240, variant239) + } + + variant241 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result212, result216, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))}, golem_core_types.SchemaValueTree{result240, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4)))}}) + + default: + panic("unreachable") + } + + variant242 = MakeRpcErrorRemoteAgentError(variant241) + + default: + panic("unreachable") + } + + result243 = witTypes.Err[InvocationMetadata, RpcError](variant242) + default: + panic("unreachable") + } + result244 := result243 + return result244 + +} + +//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 int32, arg7 int32, arg8 uintptr) + +func (self *WasmRpc) AsyncInvokeAndAwait(methodName string, input golem_core_types.SchemaValueTree, scopeCard witTypes.Option[*golem_core_types.PermissionCard]) 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + var option int32 + var option28 int32 + switch scopeCard.Tag() { + case witTypes.OptionNone: + + option = int32(0) + option28 = 0 + case witTypes.OptionSome: + payload := scopeCard.Some() + + option = int32(1) + option28 = (payload).Handle() + default: + panic("unreachable") + } + wasm_import_method_wasm_rpc_async_invoke_and_await((self).Handle(), uintptr(utf8), uint32(len(methodName)), uintptr(result26), length27, (input).Root, option, option28, returnArea) + value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) + value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + result30 := AsyncInvocationWithMetadata{InvocationMetadata{value, value29}, FutureInvokeResultFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4))))))} + return result30 + +} + +//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 int32, arg9 int32, arg10 uintptr) + +func (self *WasmRpc) ScheduleInvocation(scheduledTime wasi_clocks_0_3_0_system_clock.Instant, methodName string, input golem_core_types.SchemaValueTree, scopeCard witTypes.Option[*golem_core_types.PermissionCard]) witTypes.Result[ScheduledInvocationReceipt, 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + var option int32 + var option28 int32 + switch scopeCard.Tag() { + case witTypes.OptionNone: + + option = int32(0) + option28 = 0 + case witTypes.OptionSome: + payload := scopeCard.Some() + + option = int32(1) + option28 = (payload).Handle() + 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, option, option28, returnArea) + var result243 witTypes.Result[ScheduledInvocationReceipt, 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)))) + value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + result243 = witTypes.Ok[ScheduledInvocationReceipt, RpcError](ScheduledInvocationReceipt{InvocationMetadata{value, value29}}) + case 1: + var variant242 RpcError + 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)))) + + variant242 = MakeRpcErrorProtocolError(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)))) + + variant242 = MakeRpcErrorDenied(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)))) + + variant242 = MakeRpcErrorNotFound(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)))) + + variant242 = MakeRpcErrorRemoteInternalError(value33) + + case 4: + var variant241 golem_agent_common.AgentError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) { + case 0: + value34 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidInput(value34) + + case 1: + value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidMethod(value35) + + case 2: + value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidType(value36) + + case 3: + value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidAgentId(value37) + + case 4: + result212 := 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 variant200 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant200 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant200 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option43 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option43 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option38 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option38 = 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") + } + + option38 = witTypes.Some[golem_core_types.NumericBound](variant) + default: + panic("unreachable") + } + var option40 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option40 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant39 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant39 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant39 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant39 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option40 = witTypes.Some[golem_core_types.NumericBound](variant39) + default: + panic("unreachable") + } + var option42 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option42 = witTypes.None[string]() + case 1: + value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option42 = witTypes.Some[string](value41) + default: + panic("unreachable") + } + + option43 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option38, option40, option42}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS8Type(option43) + + case 3: + var option50 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option50 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option45 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant44 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant44 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant44 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option45 = witTypes.Some[golem_core_types.NumericBound](variant44) + default: + panic("unreachable") + } + var option47 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option47 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant46 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant46 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant46 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant46 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option47 = witTypes.Some[golem_core_types.NumericBound](variant46) + default: + panic("unreachable") + } + var option49 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option49 = witTypes.None[string]() + case 1: + value48 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option49 = witTypes.Some[string](value48) + default: + panic("unreachable") + } + + option50 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option45, option47, option49}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS16Type(option50) + + case 4: + var option57 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option57 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option52 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant51 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant51 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant51 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option52 = witTypes.Some[golem_core_types.NumericBound](variant51) + default: + panic("unreachable") + } + var option54 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option54 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant53 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant53 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant53 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant53 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option54 = witTypes.Some[golem_core_types.NumericBound](variant53) + default: + panic("unreachable") + } + var option56 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option56 = witTypes.None[string]() + case 1: + value55 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option56 = witTypes.Some[string](value55) + default: + panic("unreachable") + } + + option57 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option52, option54, option56}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS32Type(option57) + + case 5: + var option64 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option64 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option59 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant58 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant58 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant58 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option59 = witTypes.Some[golem_core_types.NumericBound](variant58) + default: + panic("unreachable") + } + var option61 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant60 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant60 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant60 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option61 = witTypes.Some[golem_core_types.NumericBound](variant60) + default: + panic("unreachable") + } + var option63 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option63 = witTypes.None[string]() + case 1: + value62 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option63 = witTypes.Some[string](value62) + default: + panic("unreachable") + } + + option64 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option59, option61, option63}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS64Type(option64) + + case 6: + var option71 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option71 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option66 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant65 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant65 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant65 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option66 = witTypes.Some[golem_core_types.NumericBound](variant65) + default: + panic("unreachable") + } + var option68 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant67 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant67 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant67 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option68 = witTypes.Some[golem_core_types.NumericBound](variant67) + default: + panic("unreachable") + } + var option70 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option70 = witTypes.None[string]() + case 1: + value69 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option70 = witTypes.Some[string](value69) + default: + panic("unreachable") + } + + option71 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option66, option68, option70}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU8Type(option71) + + case 7: + var option78 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option78 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option73 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant72 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant72 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant72 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option73 = witTypes.Some[golem_core_types.NumericBound](variant72) + default: + panic("unreachable") + } + var option75 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant74 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant74 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant74 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option75 = witTypes.Some[golem_core_types.NumericBound](variant74) + default: + panic("unreachable") + } + var option77 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option77 = witTypes.None[string]() + case 1: + value76 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option77 = witTypes.Some[string](value76) + default: + panic("unreachable") + } + + option78 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option73, option75, option77}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU16Type(option78) + + case 8: + var option85 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option85 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option80 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant79 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant79 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant79 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option80 = witTypes.Some[golem_core_types.NumericBound](variant79) + default: + panic("unreachable") + } + var option82 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant81 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant81 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant81 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option82 = witTypes.Some[golem_core_types.NumericBound](variant81) + default: + panic("unreachable") + } + var option84 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option84 = witTypes.None[string]() + case 1: + value83 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option84 = witTypes.Some[string](value83) + default: + panic("unreachable") + } + + option85 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option80, option82, option84}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU32Type(option85) + + case 9: + var option92 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option92 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option87 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant86 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant86 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant86 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option87 = witTypes.Some[golem_core_types.NumericBound](variant86) + default: + panic("unreachable") + } + var option89 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant88 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant88 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant88 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option89 = witTypes.Some[golem_core_types.NumericBound](variant88) + default: + panic("unreachable") + } + var option91 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option91 = witTypes.None[string]() + case 1: + value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option91 = witTypes.Some[string](value90) + default: + panic("unreachable") + } + + option92 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option87, option89, option91}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU64Type(option92) + + case 10: + var option99 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option99 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option94 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant93 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant93 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant93 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option94 = witTypes.Some[golem_core_types.NumericBound](variant93) + default: + panic("unreachable") + } + var option96 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant95 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant95 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant95 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option96 = witTypes.Some[golem_core_types.NumericBound](variant95) + default: + panic("unreachable") + } + var option98 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option98 = witTypes.None[string]() + case 1: + value97 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option98 = witTypes.Some[string](value97) + default: + panic("unreachable") + } + + option99 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option94, option96, option98}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyF32Type(option99) + + case 11: + var option106 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option106 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option101 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant100 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant100 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant100 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option101 = witTypes.Some[golem_core_types.NumericBound](variant100) + default: + panic("unreachable") + } + var option103 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option103 = witTypes.Some[golem_core_types.NumericBound](variant102) + default: + panic("unreachable") + } + var option105 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option105 = witTypes.None[string]() + case 1: + value104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option105 = witTypes.Some[string](value104) + default: + panic("unreachable") + } + + option106 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option101, option103, option105}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyF64Type(option106) + + case 12: + + variant200 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant200 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result119 := 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)) + value107 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option109 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option109 = witTypes.None[string]() + case 1: + value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option109 = witTypes.Some[string](value108) + default: + panic("unreachable") + } + result111 := 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)) + 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) + } + + result113 := 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)) + value112 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result113 = append(result113, value112) + } + + var option115 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option115 = witTypes.None[string]() + case 1: + value114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option115 = witTypes.Some[string](value114) + default: + panic("unreachable") + } + var option118 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option118 = witTypes.None[golem_core_types.Role]() + case 1: + var variant117 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant117 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant117 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant117 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant117 = golem_core_types.MakeRoleOther(value116) + + default: + panic("unreachable") + } + + option118 = witTypes.Some[golem_core_types.Role](variant117) + default: + panic("unreachable") + } + + result119 = append(result119, golem_core_types.NamedFieldType{value107, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option109, result111, result113, option115, option118}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyRecordType(result119) + + case 15: + result133 := 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)) + value120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option121 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option121 = witTypes.None[int32]() + case 1: + + option121 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option123 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option123 = witTypes.None[string]() + case 1: + value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option123 = witTypes.Some[string](value122) + default: + panic("unreachable") + } + result125 := 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)) + 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) + } + + result127 := 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)) + 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[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option129 = witTypes.None[string]() + case 1: + value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option129 = witTypes.Some[string](value128) + default: + panic("unreachable") + } + var option132 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option132 = witTypes.None[golem_core_types.Role]() + case 1: + var variant131 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant131 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant131 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant131 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant131 = golem_core_types.MakeRoleOther(value130) + + default: + panic("unreachable") + } + + option132 = witTypes.Some[golem_core_types.Role](variant131) + default: + panic("unreachable") + } + + result133 = append(result133, golem_core_types.VariantCaseType{value120, option121, golem_core_types.MetadataEnvelope{option123, result125, result127, option129, option132}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyVariantType(result133) + + case 16: + 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) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyEnumType(result135) + + case 17: + result137 := 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)) + value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result137 = append(result137, value136) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyFlagsType(result137) + + case 18: + result138 := 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) + + result138 = append(result138, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyTupleType(result138) + + case 19: + + variant200 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant200 = 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: + + variant200 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant200 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option139 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option139 = witTypes.None[int32]() + case 1: + + option139 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option140 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option140 = witTypes.None[int32]() + case 1: + + option140 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option139, option140}) + + case 24: + var option143 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option143 = witTypes.None[[]string]() + case 1: + result142 := 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)) + value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result142 = append(result142, value141) + } + + option143 = witTypes.Some[[]string](result142) + default: + panic("unreachable") + } + var option144 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option144 = witTypes.None[uint32]() + case 1: + + option144 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option145 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option145 = witTypes.None[uint32]() + case 1: + + option145 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option147 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option147 = witTypes.None[string]() + case 1: + value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option147 = witTypes.Some[string](value146) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option143, option144, option145, option147}) + + case 25: + var option150 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option150 = witTypes.None[[]string]() + case 1: + result149 := 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)) + 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") + } + var option151 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option151 = witTypes.None[uint32]() + case 1: + + option151 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option152 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option152 = witTypes.None[uint32]() + case 1: + + option152 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option150, option151, option152}) + + case 26: + var option155 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option155 = witTypes.None[[]string]() + case 1: + result154 := 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)) + value153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result154 = append(result154, value153) + } + + option155 = witTypes.Some[[]string](result154) + default: + panic("unreachable") + } + var option158 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option158 = witTypes.None[[]string]() + case 1: + result157 := 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)) + value156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result157 = append(result157, value156) + } + + option158 = witTypes.Some[[]string](result157) + default: + panic("unreachable") + } + + variant200 = 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)))), option155, option158}) + + case 27: + var option161 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option161 = witTypes.None[[]string]() + case 1: + result160 := 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)) + 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) + } + + option161 = witTypes.Some[[]string](result160) + default: + panic("unreachable") + } + var option164 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option164 = witTypes.None[[]string]() + case 1: + result163 := 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)) + 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) + } + + option164 = witTypes.Some[[]string](result163) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option161, option164}) + + case 28: + + variant200 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant200 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result167 := 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)) + value166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result167 = append(result167, value166) + } + + var option169 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option169 = 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))), value168}) + default: + panic("unreachable") + } + var option171 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option171 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option171 = 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))), value170}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value165, result167, option169, option171}) + + case 31: + result193 := 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)) + value172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant181 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRulePrefix(value173) + + case 1: + value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleSuffix(value174) + + case 2: + value175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleContains(value175) + + case 3: + value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleRegex(value176) + + case 4: + value177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option179 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option179 = witTypes.None[string]() + case 1: + value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option179 = witTypes.Some[string](value178) + default: + panic("unreachable") + } + + variant181 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value177, option179}) + + case 5: + value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value180) + + default: + panic("unreachable") + } + var option183 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option183 = witTypes.None[string]() + case 1: + value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option183 = witTypes.Some[string](value182) + default: + panic("unreachable") + } + result185 := 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)) + 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) + } + + result187 := 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)) + value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result187 = append(result187, value186) + } + + var option189 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option189 = witTypes.None[string]() + case 1: + value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option189 = witTypes.Some[string](value188) + default: + panic("unreachable") + } + var option192 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option192 = witTypes.None[golem_core_types.Role]() + case 1: + var variant191 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant191 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant191 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant191 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant191 = golem_core_types.MakeRoleOther(value190) + + default: + panic("unreachable") + } + + option192 = witTypes.Some[golem_core_types.Role](variant191) + default: + panic("unreachable") + } + + result193 = append(result193, golem_core_types.UnionBranch{value172, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant181, golem_core_types.MetadataEnvelope{option183, result185, result187, option189, option192}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result193}) + + case 32: + var option195 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option195 = witTypes.None[string]() + case 1: + value194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option195 = witTypes.Some[string](value194) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option195}) + + case 33: + var option197 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option197 = witTypes.None[string]() + case 1: + value196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option197 = witTypes.Some[string](value196) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option197}) + + case 34: + + variant200 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyFutureType(option198) + + case 36: + var option199 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option199 = witTypes.None[int32]() + case 1: + + option199 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyStreamType(option199) + + default: + panic("unreachable") + } + var option202 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option202 = witTypes.None[string]() + case 1: + value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option202 = witTypes.Some[string](value201) + default: + panic("unreachable") + } + result204 := 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)) + 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) + } + + result206 := 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)) + value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result206 = append(result206, value205) + } + + var option208 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option208 = witTypes.None[string]() + case 1: + value207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option208 = witTypes.Some[string](value207) + default: + panic("unreachable") + } + var option211 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option211 = witTypes.None[golem_core_types.Role]() + case 1: + var variant210 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant210 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant210 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant210 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant210 = golem_core_types.MakeRoleOther(value209) + + default: + panic("unreachable") + } + + option211 = witTypes.Some[golem_core_types.Role](variant210) + default: + panic("unreachable") + } + + result212 = append(result212, golem_core_types.SchemaTypeNode{variant200, golem_core_types.MetadataEnvelope{option202, result204, result206, option208, option211}}) + } + + result216 := 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)) + value213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option215 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option215 = witTypes.None[string]() + case 1: + value214 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option215 = witTypes.Some[string](value214) + default: + panic("unreachable") + } + + result216 = append(result216, golem_core_types.SchemaTypeDef{value213, option215, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result240 := 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 variant239 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant239 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant239 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant239 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant239 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant239 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant239 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant239 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant239 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant239 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant239 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant239 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant239 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeStringValue(value217) + + case 13: + 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))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeRecordValue(result218) + + case 14: + 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") + } + + variant239 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option219}) + + case 15: + + variant239 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result220 := 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) + + result220 = append(result220, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant239 = golem_core_types.MakeSchemaValueNodeFlagsValue(result220) + + case 17: + 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))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeTupleValue(result221) + + case 18: + result222 := 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) + + result222 = append(result222, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeListValue(result222) + + case 19: + result223 := 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) + + result223 = append(result223, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeFixedListValue(result223) + + case 20: + result224 := 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) + + result224 = append(result224, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant239 = golem_core_types.MakeSchemaValueNodeMapValue(result224) + + case 21: + var option225 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option225 = witTypes.None[int32]() + case 1: + + option225 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeOptionValue(option225) + + case 22: + var variant228 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option226 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option226 = witTypes.None[int32]() + case 1: + + option226 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant228 = golem_core_types.MakeResultValuePayloadOkValue(option226) + + case 1: + var option227 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option227 = witTypes.None[int32]() + case 1: + + option227 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant228 = golem_core_types.MakeResultValuePayloadErrValue(option227) + + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeResultValue(variant228) + + case 23: + value229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option231 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option231 = witTypes.None[string]() + case 1: + value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option231 = witTypes.Some[string](value230) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value229, option231}) + + case 24: + value232 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option234 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option234 = witTypes.None[string]() + case 1: + value233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option234 = witTypes.Some[string](value233) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value232, option234}) + + case 25: + value235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodePathValue(value235) + + case 26: + value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeUrlValue(value236) + + case 27: + + variant239 = 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: + + variant239 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value237}) + + case 30: + value238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value238, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant239 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant239 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant239 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result240 = append(result240, variant239) + } + + variant241 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result212, result216, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))}, golem_core_types.SchemaValueTree{result240, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4)))}}) + + default: + panic("unreachable") + } + + variant242 = MakeRpcErrorRemoteAgentError(variant241) + + default: + panic("unreachable") + } + + result243 = witTypes.Err[ScheduledInvocationReceipt, RpcError](variant242) + default: + panic("unreachable") + } + result244 := result243 + return result244 + +} + +//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 int32, arg9 int32, arg10 uintptr) + +func (self *WasmRpc) ScheduleCancelableInvocation(scheduledTime wasi_clocks_0_3_0_system_clock.Instant, methodName string, input golem_core_types.SchemaValueTree, scopeCard witTypes.Option[*golem_core_types.PermissionCard]) witTypes.Result[CancelableScheduledInvocationReceipt, 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + var option int32 + var option28 int32 + switch scopeCard.Tag() { + case witTypes.OptionNone: + + option = int32(0) + option28 = 0 + case witTypes.OptionSome: + payload := scopeCard.Some() + + option = int32(1) + option28 = (payload).Handle() + 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, option, option28, returnArea) + var result243 witTypes.Result[CancelableScheduledInvocationReceipt, 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)))) + value29 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + result243 = witTypes.Ok[CancelableScheduledInvocationReceipt, RpcError](CancelableScheduledInvocationReceipt{InvocationMetadata{value, value29}, CancellationTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))))}) + case 1: + var variant242 RpcError + 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)))) + + variant242 = MakeRpcErrorProtocolError(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)))) + + variant242 = MakeRpcErrorDenied(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)))) + + variant242 = MakeRpcErrorNotFound(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)))) + + variant242 = MakeRpcErrorRemoteInternalError(value33) + + case 4: + var variant241 golem_agent_common.AgentError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) { + case 0: + value34 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidInput(value34) + + case 1: + value35 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidMethod(value35) + + case 2: + value36 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidType(value36) + + case 3: + value37 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))) + + variant241 = golem_agent_common.MakeAgentErrorInvalidAgentId(value37) + + case 4: + result212 := 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 variant200 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant200 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant200 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option43 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option43 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option38 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option38 = 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") + } + + option38 = witTypes.Some[golem_core_types.NumericBound](variant) + default: + panic("unreachable") + } + var option40 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option40 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant39 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant39 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant39 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant39 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option40 = witTypes.Some[golem_core_types.NumericBound](variant39) + default: + panic("unreachable") + } + var option42 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option42 = witTypes.None[string]() + case 1: + value41 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option42 = witTypes.Some[string](value41) + default: + panic("unreachable") + } + + option43 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option38, option40, option42}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS8Type(option43) + + case 3: + var option50 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option50 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option45 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant44 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant44 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant44 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option45 = witTypes.Some[golem_core_types.NumericBound](variant44) + default: + panic("unreachable") + } + var option47 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option47 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant46 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant46 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant46 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant46 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option47 = witTypes.Some[golem_core_types.NumericBound](variant46) + default: + panic("unreachable") + } + var option49 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option49 = witTypes.None[string]() + case 1: + value48 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option49 = witTypes.Some[string](value48) + default: + panic("unreachable") + } + + option50 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option45, option47, option49}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS16Type(option50) + + case 4: + var option57 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option57 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option52 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant51 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant51 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant51 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option52 = witTypes.Some[golem_core_types.NumericBound](variant51) + default: + panic("unreachable") + } + var option54 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option54 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant53 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant53 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant53 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant53 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option54 = witTypes.Some[golem_core_types.NumericBound](variant53) + default: + panic("unreachable") + } + var option56 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option56 = witTypes.None[string]() + case 1: + value55 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option56 = witTypes.Some[string](value55) + default: + panic("unreachable") + } + + option57 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option52, option54, option56}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS32Type(option57) + + case 5: + var option64 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option64 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option59 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant58 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant58 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant58 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option59 = witTypes.Some[golem_core_types.NumericBound](variant58) + default: + panic("unreachable") + } + var option61 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant60 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant60 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant60 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option61 = witTypes.Some[golem_core_types.NumericBound](variant60) + default: + panic("unreachable") + } + var option63 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option63 = witTypes.None[string]() + case 1: + value62 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option63 = witTypes.Some[string](value62) + default: + panic("unreachable") + } + + option64 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option59, option61, option63}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyS64Type(option64) + + case 6: + var option71 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option71 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option66 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant65 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant65 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant65 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option66 = witTypes.Some[golem_core_types.NumericBound](variant65) + default: + panic("unreachable") + } + var option68 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant67 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant67 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant67 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option68 = witTypes.Some[golem_core_types.NumericBound](variant67) + default: + panic("unreachable") + } + var option70 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option70 = witTypes.None[string]() + case 1: + value69 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option70 = witTypes.Some[string](value69) + default: + panic("unreachable") + } + + option71 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option66, option68, option70}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU8Type(option71) + + case 7: + var option78 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option78 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option73 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant72 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant72 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant72 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option73 = witTypes.Some[golem_core_types.NumericBound](variant72) + default: + panic("unreachable") + } + var option75 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant74 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant74 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant74 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option75 = witTypes.Some[golem_core_types.NumericBound](variant74) + default: + panic("unreachable") + } + var option77 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option77 = witTypes.None[string]() + case 1: + value76 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option77 = witTypes.Some[string](value76) + default: + panic("unreachable") + } + + option78 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option73, option75, option77}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU16Type(option78) + + case 8: + var option85 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option85 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option80 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant79 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant79 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant79 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option80 = witTypes.Some[golem_core_types.NumericBound](variant79) + default: + panic("unreachable") + } + var option82 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant81 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant81 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant81 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option82 = witTypes.Some[golem_core_types.NumericBound](variant81) + default: + panic("unreachable") + } + var option84 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option84 = witTypes.None[string]() + case 1: + value83 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option84 = witTypes.Some[string](value83) + default: + panic("unreachable") + } + + option85 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option80, option82, option84}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU32Type(option85) + + case 9: + var option92 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option92 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option87 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant86 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant86 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant86 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option87 = witTypes.Some[golem_core_types.NumericBound](variant86) + default: + panic("unreachable") + } + var option89 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant88 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant88 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant88 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option89 = witTypes.Some[golem_core_types.NumericBound](variant88) + default: + panic("unreachable") + } + var option91 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option91 = witTypes.None[string]() + case 1: + value90 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option91 = witTypes.Some[string](value90) + default: + panic("unreachable") + } + + option92 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option87, option89, option91}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyU64Type(option92) + + case 10: + var option99 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option99 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option94 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant93 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant93 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant93 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option94 = witTypes.Some[golem_core_types.NumericBound](variant93) + default: + panic("unreachable") + } + var option96 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant95 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant95 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant95 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option96 = witTypes.Some[golem_core_types.NumericBound](variant95) + default: + panic("unreachable") + } + var option98 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option98 = witTypes.None[string]() + case 1: + value97 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option98 = witTypes.Some[string](value97) + default: + panic("unreachable") + } + + option99 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option94, option96, option98}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyF32Type(option99) + + case 11: + var option106 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option106 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option101 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant100 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant100 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant100 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option101 = witTypes.Some[golem_core_types.NumericBound](variant100) + default: + panic("unreachable") + } + var option103 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option103 = witTypes.Some[golem_core_types.NumericBound](variant102) + default: + panic("unreachable") + } + var option105 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option105 = witTypes.None[string]() + case 1: + value104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option105 = witTypes.Some[string](value104) + default: + panic("unreachable") + } + + option106 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option101, option103, option105}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyF64Type(option106) + + case 12: + + variant200 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant200 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result119 := 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)) + value107 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option109 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option109 = witTypes.None[string]() + case 1: + value108 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option109 = witTypes.Some[string](value108) + default: + panic("unreachable") + } + result111 := 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)) + 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) + } + + result113 := 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)) + value112 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result113 = append(result113, value112) + } + + var option115 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option115 = witTypes.None[string]() + case 1: + value114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option115 = witTypes.Some[string](value114) + default: + panic("unreachable") + } + var option118 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option118 = witTypes.None[golem_core_types.Role]() + case 1: + var variant117 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant117 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant117 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant117 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value116 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant117 = golem_core_types.MakeRoleOther(value116) + + default: + panic("unreachable") + } + + option118 = witTypes.Some[golem_core_types.Role](variant117) + default: + panic("unreachable") + } + + result119 = append(result119, golem_core_types.NamedFieldType{value107, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option109, result111, result113, option115, option118}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyRecordType(result119) + + case 15: + result133 := 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)) + value120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option121 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option121 = witTypes.None[int32]() + case 1: + + option121 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option123 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option123 = witTypes.None[string]() + case 1: + value122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option123 = witTypes.Some[string](value122) + default: + panic("unreachable") + } + result125 := 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)) + 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) + } + + result127 := 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)) + 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[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option129 = witTypes.None[string]() + case 1: + value128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option129 = witTypes.Some[string](value128) + default: + panic("unreachable") + } + var option132 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option132 = witTypes.None[golem_core_types.Role]() + case 1: + var variant131 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant131 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant131 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant131 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant131 = golem_core_types.MakeRoleOther(value130) + + default: + panic("unreachable") + } + + option132 = witTypes.Some[golem_core_types.Role](variant131) + default: + panic("unreachable") + } + + result133 = append(result133, golem_core_types.VariantCaseType{value120, option121, golem_core_types.MetadataEnvelope{option123, result125, result127, option129, option132}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyVariantType(result133) + + case 16: + 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) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyEnumType(result135) + + case 17: + result137 := 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)) + value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result137 = append(result137, value136) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyFlagsType(result137) + + case 18: + result138 := 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) + + result138 = append(result138, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyTupleType(result138) + + case 19: + + variant200 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant200 = 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: + + variant200 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant200 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option139 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option139 = witTypes.None[int32]() + case 1: + + option139 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option140 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option140 = witTypes.None[int32]() + case 1: + + option140 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option139, option140}) + + case 24: + var option143 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option143 = witTypes.None[[]string]() + case 1: + result142 := 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)) + value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result142 = append(result142, value141) + } + + option143 = witTypes.Some[[]string](result142) + default: + panic("unreachable") + } + var option144 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option144 = witTypes.None[uint32]() + case 1: + + option144 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option145 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option145 = witTypes.None[uint32]() + case 1: + + option145 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option147 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option147 = witTypes.None[string]() + case 1: + value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option147 = witTypes.Some[string](value146) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option143, option144, option145, option147}) + + case 25: + var option150 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option150 = witTypes.None[[]string]() + case 1: + result149 := 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)) + 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") + } + var option151 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option151 = witTypes.None[uint32]() + case 1: + + option151 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option152 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option152 = witTypes.None[uint32]() + case 1: + + option152 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option150, option151, option152}) + + case 26: + var option155 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option155 = witTypes.None[[]string]() + case 1: + result154 := 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)) + value153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result154 = append(result154, value153) + } + + option155 = witTypes.Some[[]string](result154) + default: + panic("unreachable") + } + var option158 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option158 = witTypes.None[[]string]() + case 1: + result157 := 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)) + value156 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result157 = append(result157, value156) + } + + option158 = witTypes.Some[[]string](result157) + default: + panic("unreachable") + } + + variant200 = 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)))), option155, option158}) + + case 27: + var option161 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option161 = witTypes.None[[]string]() + case 1: + result160 := 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)) + 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) + } + + option161 = witTypes.Some[[]string](result160) + default: + panic("unreachable") + } + var option164 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option164 = witTypes.None[[]string]() + case 1: + result163 := 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)) + 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) + } + + option164 = witTypes.Some[[]string](result163) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option161, option164}) + + case 28: + + variant200 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant200 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result167 := 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)) + value166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result167 = append(result167, value166) + } + + var option169 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option169 = 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))), value168}) + default: + panic("unreachable") + } + var option171 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option171 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option171 = 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))), value170}) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value165, result167, option169, option171}) + + case 31: + result193 := 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)) + value172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant181 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRulePrefix(value173) + + case 1: + value174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleSuffix(value174) + + case 2: + value175 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleContains(value175) + + case 3: + value176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleRegex(value176) + + case 4: + value177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option179 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option179 = witTypes.None[string]() + case 1: + value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option179 = witTypes.Some[string](value178) + default: + panic("unreachable") + } + + variant181 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value177, option179}) + + case 5: + value180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant181 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value180) + + default: + panic("unreachable") + } + var option183 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option183 = witTypes.None[string]() + case 1: + value182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option183 = witTypes.Some[string](value182) + default: + panic("unreachable") + } + result185 := 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)) + 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) + } + + result187 := 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)) + value186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result187 = append(result187, value186) + } + + var option189 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option189 = witTypes.None[string]() + case 1: + value188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option189 = witTypes.Some[string](value188) + default: + panic("unreachable") + } + var option192 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option192 = witTypes.None[golem_core_types.Role]() + case 1: + var variant191 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant191 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant191 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant191 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant191 = golem_core_types.MakeRoleOther(value190) + + default: + panic("unreachable") + } + + option192 = witTypes.Some[golem_core_types.Role](variant191) + default: + panic("unreachable") + } + + result193 = append(result193, golem_core_types.UnionBranch{value172, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant181, golem_core_types.MetadataEnvelope{option183, result185, result187, option189, option192}}) + } + + variant200 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result193}) + + case 32: + var option195 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option195 = witTypes.None[string]() + case 1: + value194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option195 = witTypes.Some[string](value194) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option195}) + + case 33: + var option197 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option197 = witTypes.None[string]() + case 1: + value196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option197 = witTypes.Some[string](value196) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option197}) + + case 34: + + variant200 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyFutureType(option198) + + case 36: + var option199 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option199 = witTypes.None[int32]() + case 1: + + option199 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant200 = golem_core_types.MakeSchemaTypeBodyStreamType(option199) + + default: + panic("unreachable") + } + var option202 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option202 = witTypes.None[string]() + case 1: + value201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option202 = witTypes.Some[string](value201) + default: + panic("unreachable") + } + result204 := 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)) + 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) + } + + result206 := 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)) + value205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result206 = append(result206, value205) + } + + var option208 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option208 = witTypes.None[string]() + case 1: + value207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option208 = witTypes.Some[string](value207) + default: + panic("unreachable") + } + var option211 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option211 = witTypes.None[golem_core_types.Role]() + case 1: + var variant210 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant210 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant210 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant210 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant210 = golem_core_types.MakeRoleOther(value209) + + default: + panic("unreachable") + } + + option211 = witTypes.Some[golem_core_types.Role](variant210) + default: + panic("unreachable") + } + + result212 = append(result212, golem_core_types.SchemaTypeNode{variant200, golem_core_types.MetadataEnvelope{option202, result204, result206, option208, option211}}) + } + + result216 := 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)) + value213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option215 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option215 = witTypes.None[string]() + case 1: + value214 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option215 = witTypes.Some[string](value214) + default: + panic("unreachable") + } + + result216 = append(result216, golem_core_types.SchemaTypeDef{value213, option215, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result240 := 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 variant239 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant239 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant239 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant239 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant239 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant239 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant239 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant239 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant239 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant239 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant239 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant239 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant239 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeStringValue(value217) + + case 13: + 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))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeRecordValue(result218) + + case 14: + 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") + } + + variant239 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option219}) + + case 15: + + variant239 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result220 := 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) + + result220 = append(result220, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant239 = golem_core_types.MakeSchemaValueNodeFlagsValue(result220) + + case 17: + 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))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeTupleValue(result221) + + case 18: + result222 := 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) + + result222 = append(result222, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeListValue(result222) + + case 19: + result223 := 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) + + result223 = append(result223, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant239 = golem_core_types.MakeSchemaValueNodeFixedListValue(result223) + + case 20: + result224 := 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) + + result224 = append(result224, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant239 = golem_core_types.MakeSchemaValueNodeMapValue(result224) + + case 21: + var option225 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option225 = witTypes.None[int32]() + case 1: + + option225 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeOptionValue(option225) + + case 22: + var variant228 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option226 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option226 = witTypes.None[int32]() + case 1: + + option226 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant228 = golem_core_types.MakeResultValuePayloadOkValue(option226) + + case 1: + var option227 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option227 = witTypes.None[int32]() + case 1: + + option227 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant228 = golem_core_types.MakeResultValuePayloadErrValue(option227) + + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeResultValue(variant228) + + case 23: + value229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option231 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option231 = witTypes.None[string]() + case 1: + value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option231 = witTypes.Some[string](value230) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value229, option231}) + + case 24: + value232 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option234 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option234 = witTypes.None[string]() + case 1: + value233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option234 = witTypes.Some[string](value233) + default: + panic("unreachable") + } + + variant239 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value232, option234}) + + case 25: + value235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodePathValue(value235) + + case 26: + value236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeUrlValue(value236) + + case 27: + + variant239 = 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: + + variant239 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value237}) + + case 30: + value238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant239 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value238, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant239 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant239 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant239 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result240 = append(result240, variant239) + } + + variant241 = golem_agent_common.MakeAgentErrorCustomError(golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result212, result216, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (7 * 4)))}, golem_core_types.SchemaValueTree{result240, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (10 * 4)))}}) + + default: + panic("unreachable") + } + + variant242 = MakeRpcErrorRemoteAgentError(variant241) + + default: + panic("unreachable") + } + + result243 = witTypes.Err[CancelableScheduledInvocationReceipt, RpcError](variant242) + default: + panic("unreachable") + } + result244 := result243 + return result244 + +} + +//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)))))) + + case 33: + + variant18 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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: + + variant192 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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)))))) + + case 33: + + variant231 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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) witTypes.Result[golem_core_types.SchemaValueTree, ConfigValueError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 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))) + + } + + slice119 := (expected).TypeNodes + length121 := uint32(len(slice119)) + result120 := witRuntime.Allocate(pinner, uintptr(length121*(56+22*4)), 8) + for index, element := range slice119 { + base := unsafe.Add(result120, 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result107 int32 + if (payload).Polymorphic { + result107 = 1 + } else { + result107 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result107) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8108 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8108) + *(*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(utf8108))) + + default: + panic("unreachable") + } + slice110 := ((element).Metadata).Aliases + 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 + 12*4))) = uint32(length112) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result111))) + slice114 := ((element).Metadata).Examples + 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), (56 + 14*4))) = uint32(length116) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result115))) + + 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)) + utf8117 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8117) + *(*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(utf8117))) + + 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)) + utf8118 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8118) + *(*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(utf8118))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + slice124 := (expected).Defs + length126 := uint32(len(slice124)) + result125 := witRuntime.Allocate(pinner, uintptr(length126*(6*4)), 4) + for index, element := range slice124 { + base := unsafe.Add(result125, index*(6*4)) + utf8122 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8122) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8122))) + + 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)) + utf8123 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8123) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8123))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + wasm_import_get_config_value(uintptr(result), length, uintptr(result120), length121, uintptr(result125), length126, (expected).Root, returnArea) + var result149 witTypes.Result[golem_core_types.SchemaValueTree, ConfigValueError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + result147 := 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 variant146 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant146 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant146 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant146 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant146 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant146 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant146 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant146 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant146 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant146 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant146 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant146 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant146 = 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)))) + + variant146 = golem_core_types.MakeSchemaValueNodeStringValue(value) + + case 13: + result127 := 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) + + result127 = append(result127, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant146 = golem_core_types.MakeSchemaValueNodeRecordValue(result127) + + 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") + } + + variant146 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option}) + + case 15: + + variant146 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result128 := 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) + + result128 = append(result128, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant146 = golem_core_types.MakeSchemaValueNodeFlagsValue(result128) + + case 17: + 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))) + } + + variant146 = golem_core_types.MakeSchemaValueNodeTupleValue(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))) + } + + variant146 = golem_core_types.MakeSchemaValueNodeListValue(result130) + + case 19: + result131 := 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) + + result131 = append(result131, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant146 = golem_core_types.MakeSchemaValueNodeFixedListValue(result131) + + case 20: + result132 := 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) + + result132 = append(result132, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant146 = golem_core_types.MakeSchemaValueNodeMapValue(result132) + + case 21: + var option133 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option133 = witTypes.None[int32]() + case 1: + + option133 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant146 = golem_core_types.MakeSchemaValueNodeOptionValue(option133) + + case 22: + var variant golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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.MakeResultValuePayloadOkValue(option134) + + case 1: + var option135 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option135 = witTypes.None[int32]() + case 1: + + option135 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant = golem_core_types.MakeResultValuePayloadErrValue(option135) + + default: + panic("unreachable") + } + + variant146 = golem_core_types.MakeSchemaValueNodeResultValue(variant) + + case 23: + value136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option138 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option138 = witTypes.None[string]() + case 1: + value137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option138 = witTypes.Some[string](value137) + default: + panic("unreachable") + } + + variant146 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value136, option138}) + + case 24: + value139 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option141 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option141 = witTypes.None[string]() + case 1: + value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option141 = witTypes.Some[string](value140) + default: + panic("unreachable") + } + + variant146 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value139, option141}) + + case 25: + value142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant146 = golem_core_types.MakeSchemaValueNodePathValue(value142) + + case 26: + value143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant146 = golem_core_types.MakeSchemaValueNodeUrlValue(value143) + + case 27: + + variant146 = 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: + + variant146 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant146 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value144}) + + case 30: + value145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant146 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value145, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant146 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant146 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant146 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result147 = append(result147, variant146) + } + + result149 = witTypes.Ok[golem_core_types.SchemaValueTree, ConfigValueError](golem_core_types.SchemaValueTree{result147, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))}) + case 1: + var variant148 ConfigValueError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant148 = MakeConfigValueErrorPermissionDenied() + + default: + panic("unreachable") + } + + result149 = witTypes.Err[golem_core_types.SchemaValueTree, ConfigValueError](variant148) + default: + panic("unreachable") + } + result150 := result149 + return result150 + +} 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..8a8a8b41c4 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_api_context/wit_bindings.go @@ -0,0 +1,534 @@ +// 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.6.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:permissions@0.1.0 +// 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..57f717a2dd --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_api_host/wit_bindings.go @@ -0,0 +1,1211 @@ +// 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.6.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:permissions@0.1.0 +// 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 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 ( + // 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} +} + +const ( + AgentOperationErrorPermissionDenied uint8 = 0 + AgentOperationErrorBackendError uint8 = 1 +) + +// Error returned by an operation targeting another agent. +type AgentOperationError struct { + tag uint8 + value any +} + +func (self AgentOperationError) Tag() uint8 { + return self.tag +} + +func (self AgentOperationError) BackendError() string { + if self.tag != AgentOperationErrorBackendError { + panic("tag mismatch") + } + return self.value.(string) +} + +func MakeAgentOperationErrorPermissionDenied() AgentOperationError { + return AgentOperationError{AgentOperationErrorPermissionDenied, nil} +} +func MakeAgentOperationErrorBackendError(value string) AgentOperationError { + return AgentOperationError{AgentOperationErrorBackendError, 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} +} + +// 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.Result[witTypes.Option[[]AgentMetadata], AgentOperationError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4)) + wasm_import_method_get_agents_get_next((self).Handle(), returnArea) + var result9 witTypes.Result[witTypes.Option[[]AgentMetadata], AgentOperationError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + var option witTypes.Option[[]AgentMetadata] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + option = witTypes.None[[]AgentMetadata]() + case 1: + result7 := make([]AgentMetadata, 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+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") + } + + result9 = witTypes.Ok[witTypes.Option[[]AgentMetadata], AgentOperationError](option) + case 1: + var variant AgentOperationError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant = MakeAgentOperationErrorPermissionDenied() + + case 1: + value8 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant = MakeAgentOperationErrorBackendError(value8) + + default: + panic("unreachable") + } + + result9 = witTypes.Err[witTypes.Option[[]AgentMetadata], AgentOperationError](variant) + default: + panic("unreachable") + } + result10 := result9 + return result10 + +} + +//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-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 update-agent +func wasm_import_update_agent(arg0 int64, arg1 int64, arg2 uintptr, arg3 uint32, arg4 int64, arg5 int32, arg6 uintptr) + +func UpdateAgent(agentId golem_core_types.AgentId, targetRevision uint64, mode UpdateMode) witTypes.Result[witTypes.Unit, AgentOperationError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4)) + 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), returnArea) + var result witTypes.Result[witTypes.Unit, AgentOperationError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + + result = witTypes.Ok[witTypes.Unit, AgentOperationError](witTypes.Unit{}) + case 1: + var variant AgentOperationError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant = MakeAgentOperationErrorPermissionDenied() + + 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)))) + + variant = MakeAgentOperationErrorBackendError(value) + + default: + panic("unreachable") + } + + result = witTypes.Err[witTypes.Unit, AgentOperationError](variant) + default: + panic("unreachable") + } + result0 := result + return result0 + +} + +//go:wasmimport golem:api/host@1.5.0 get-self-metadata +func wasm_import_get_self_metadata(arg0 uintptr) + +func GetSelfMetadata() witTypes.Result[AgentMetadata, AgentOperationError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (64 + 8*4), 8)) + wasm_import_get_self_metadata(returnArea) + var result8 witTypes.Result[AgentMetadata, AgentOperationError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + 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}) + } + + result8 = witTypes.Ok[AgentMetadata, AgentOperationError](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))))}}}) + case 1: + var variant AgentOperationError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) { + case 0: + + variant = MakeAgentOperationErrorPermissionDenied() + + case 1: + value7 := 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 = MakeAgentOperationErrorBackendError(value7) + + default: + panic("unreachable") + } + + result8 = witTypes.Err[AgentMetadata, AgentOperationError](variant) + default: + panic("unreachable") + } + result9 := result8 + return result9 + +} + +//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, arg9 uintptr) + +func ForkAgent(sourceAgentId golem_core_types.AgentId, targetAgentId golem_core_types.AgentId, oplogIdxCutOff uint64) witTypes.Result[witTypes.Unit, AgentOperationError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4)) + 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), returnArea) + var result witTypes.Result[witTypes.Unit, AgentOperationError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + + result = witTypes.Ok[witTypes.Unit, AgentOperationError](witTypes.Unit{}) + case 1: + var variant AgentOperationError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant = MakeAgentOperationErrorPermissionDenied() + + 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)))) + + variant = MakeAgentOperationErrorBackendError(value) + + default: + panic("unreachable") + } + + result = witTypes.Err[witTypes.Unit, AgentOperationError](variant) + default: + panic("unreachable") + } + result1 := result + return result1 + +} + +//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, arg6 uintptr) + +func RevertAgent(agentId golem_core_types.AgentId, revertTarget RevertAgentTarget) witTypes.Result[witTypes.Unit, AgentOperationError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4)) + 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, returnArea) + var result witTypes.Result[witTypes.Unit, AgentOperationError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + + result = witTypes.Ok[witTypes.Unit, AgentOperationError](witTypes.Unit{}) + case 1: + var variant1 AgentOperationError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant1 = MakeAgentOperationErrorPermissionDenied() + + 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)))) + + variant1 = MakeAgentOperationErrorBackendError(value) + + default: + panic("unreachable") + } + + result = witTypes.Err[witTypes.Unit, AgentOperationError](variant1) + default: + panic("unreachable") + } + result2 := result + return result2 + +} + +//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() witTypes.Result[ForkResult, AgentOperationError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, 32, 8)) + wasm_import_fork(returnArea) + var result witTypes.Result[ForkResult, AgentOperationError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + var variant ForkResult + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) { + case 0: + + variant = MakeForkResultOriginal(ForkDetails{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 24)))}}) + + case 1: + + variant = MakeForkResultForked(ForkDetails{golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 16))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 24)))}}) + + default: + panic("unreachable") + } + + result = witTypes.Ok[ForkResult, AgentOperationError](variant) + case 1: + var variant0 AgentOperationError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) { + case 0: + + variant0 = MakeAgentOperationErrorPermissionDenied() + + case 1: + 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)))) + + variant0 = MakeAgentOperationErrorBackendError(value) + + default: + panic("unreachable") + } + + result = witTypes.Err[ForkResult, AgentOperationError](variant0) + default: + panic("unreachable") + } + result1 := result + return result1 + +} 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..f6e6ffc144 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_api_load_snapshot/wit_bindings.go @@ -0,0 +1,39 @@ +// 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.6.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:permissions@0.1.0 +// 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..8ced7a0422 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_api_oplog/wit_bindings.go @@ -0,0 +1,72609 @@ +// 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.6.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:permissions@0.1.0 +// 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 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 + InvocationId witTypes.Option[golem_core_types.Uuid] + ObservationalOwner witTypes.Option[uint64] + 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 +} + +// Parameters of a `completion-delivered` entry: the successful result of the durable host +// call started at `start-index` was handed to the agent at this point in the recorded +// execution. Replay may prepare the recorded host result earlier, but does not hand it to the +// agent until this marker and prevents later oplog entries from advancing until that handoff. +type CompletionDeliveredParameters 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 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 + InvocationId witTypes.Option[golem_core_types.Uuid] + ObservationalOwner witTypes.Option[uint64] + 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 +} + +type RawCompletionDeliveredParameters 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 + // Begins a transaction operation + OplogEntryBeginRemoteTransaction uint8 = 31 + // Pre-Commit of the transaction, indicating that the transaction will be committed + OplogEntryPreCommitRemoteTransaction uint8 = 32 + // Pre-Rollback of the transaction, indicating that the transaction will be rolled back + OplogEntryPreRollbackRemoteTransaction uint8 = 33 + // Committed transaction operation, indicating that the transaction was committed + OplogEntryCommittedRemoteTransaction uint8 = 34 + // Rolled back transaction operation, indicating that the transaction was rolled back + OplogEntryRolledBackRemoteTransaction uint8 = 35 + // A snapshot of the agent's state + OplogEntrySnapshot uint8 = 36 + // Checkpoint for oplog processor plugin delivery tracking + OplogEntryOplogProcessorCheckpoint uint8 = 37 + // Sets or overwrites a named retry policy + OplogEntrySetRetryPolicy uint8 = 38 + // Removes a named retry policy by name + OplogEntryRemoveRetryPolicy uint8 = 39 + // Durable queue entry for pending permission-card work + OplogEntryCardEventQueued uint8 = 40 + // Records successful installation of a permission card into the agent wallet + OplogEntryCardInstalled uint8 = 41 + // Records failed installation of a permission card into the agent wallet + OplogEntryCardInstallFailed uint8 = 42 + // Records that a permission card used by the agent has been revoked + OplogEntryCardRevoked uint8 = 43 + // Records that a permission card used by the agent has expired + OplogEntryCardExpired uint8 = 44 + // 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 = 45 + // 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 = 46 + // The successful completion of the durable host call started by the matching `start` + // was delivered to the agent at this point in the recorded execution + OplogEntryCompletionDelivered 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) 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 (self OplogEntry) CompletionDelivered() RawCompletionDeliveredParameters { + if self.tag != OplogEntryCompletionDelivered { + panic("tag mismatch") + } + return self.value.(RawCompletionDeliveredParameters) +} + +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 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} +} +func MakeOplogEntryCompletionDelivered(value RawCompletionDeliveredParameters) OplogEntry { + return OplogEntry{OplogEntryCompletionDelivered, 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 + // Begins a transaction operation + PublicOplogEntryBeginRemoteTransaction uint8 = 31 + // Pre-Commit of the transaction, indicating that the transaction will be committed + PublicOplogEntryPreCommitRemoteTransaction uint8 = 32 + // Pre-Rollback of the transaction, indicating that the transaction will be rolled back + PublicOplogEntryPreRollbackRemoteTransaction uint8 = 33 + // Committed transaction operation, indicating that the transaction was committed + PublicOplogEntryCommittedRemoteTransaction uint8 = 34 + // Rolled back transaction operation, indicating that the transaction was rolled back + PublicOplogEntryRolledBackRemoteTransaction uint8 = 35 + // A snapshot of the worker's state + PublicOplogEntrySnapshot uint8 = 36 + // Checkpoint for oplog processor plugin delivery tracking + PublicOplogEntryOplogProcessorCheckpoint uint8 = 37 + // Sets or overwrites a named retry policy + PublicOplogEntrySetRetryPolicy uint8 = 38 + // Removes a named retry policy by name + PublicOplogEntryRemoveRetryPolicy uint8 = 39 + // Durable queue entry for pending permission-card work + PublicOplogEntryCardEventQueued uint8 = 40 + // Records successful installation of a permission card into the agent wallet + PublicOplogEntryCardInstalled uint8 = 41 + // Records failed installation of a permission card into the agent wallet + PublicOplogEntryCardInstallFailed uint8 = 42 + // Records that a permission card used by the agent has been revoked + PublicOplogEntryCardRevoked uint8 = 43 + // Records that a permission card used by the agent has expired + PublicOplogEntryCardExpired uint8 = 44 + // 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 = 45 + // 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 = 46 + // The successful completion of the durable host call started by the matching `start` + // was delivered to the agent at this point in the recorded execution + PublicOplogEntryCompletionDelivered 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) 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 (self PublicOplogEntry) CompletionDelivered() CompletionDeliveredParameters { + if self.tag != PublicOplogEntryCompletionDelivered { + panic("tag mismatch") + } + return self.value.(CompletionDeliveredParameters) +} + +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 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} +} +func MakePublicOplogEntryCompletionDelivered(value CompletionDeliveredParameters) PublicOplogEntry { + return PublicOplogEntry{PublicOplogEntryCompletionDelivered, value} +} + +const ( + OplogReadErrorPermissionDenied uint8 = 0 + OplogReadErrorInternalError uint8 = 1 +) + +type OplogReadError struct { + tag uint8 + value any +} + +func (self OplogReadError) Tag() uint8 { + return self.tag +} + +func (self OplogReadError) InternalError() string { + if self.tag != OplogReadErrorInternalError { + panic("tag mismatch") + } + return self.value.(string) +} + +func MakeOplogReadErrorPermissionDenied() OplogReadError { + return OplogReadError{OplogReadErrorPermissionDenied, nil} +} +func MakeOplogReadErrorInternalError(value string) OplogReadError { + return OplogReadError{OplogReadErrorInternalError, 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*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).InvocationId.Tag() { + case witTypes.OptionNone: + *(*int8)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))) = int8(int32(0)) + + case witTypes.OptionSome: + payload := (payload).InvocationId.Some() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4))) = int8(int32(1)) + *(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))) = int64((payload).HighBits) + *(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))) = int64((payload).LowBits) + + default: + panic("unreachable") + } + + switch (payload).ObservationalOwner.Tag() { + case witTypes.OptionNone: + *(*int8)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))) = int8(int32(0)) + + case witTypes.OptionSome: + payload := (payload).ObservationalOwner.Some() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))) = int8(int32(1)) + *(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 2*4))) = int64(payload) + + default: + panic("unreachable") + } + + switch (payload).Request.Tag() { + case witTypes.OptionNone: + *(*int8)(unsafe.Add(unsafe.Pointer(base), (88 + 2*4))) = int8(int32(0)) + + case witTypes.OptionSome: + payload := (payload).Request.Some() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (88 + 2*4))) = int8(int32(1)) + + switch payload.Tag() { + case OplogPayloadInline: + payload := payload.Inline() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (96 + 2*4))) = int8(int32(0)) + data46 := unsafe.Pointer(unsafe.SliceData(payload)) + pinner.Pin(data46) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (104 + 3*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (104 + 2*4))) = uint32(uintptr(uintptr(data46))) + + case OplogPayloadExternal: + payload := payload.External() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (96 + 2*4))) = int8(int32(1)) + *(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 2*4))) = int64(((payload).PayloadId).HighBits) + *(*int64)(unsafe.Add(unsafe.Pointer(base), (112 + 2*4))) = int64(((payload).PayloadId).LowBits) + data47 := unsafe.Pointer(unsafe.SliceData((payload).Md5Hash)) + pinner.Pin(data47) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (120 + 3*4))) = uint32(uint32(len((payload).Md5Hash))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (120 + 2*4))) = uint32(uintptr(uintptr(data47))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + switch (payload).DurableFunctionType.Tag() { + case WrappedFunctionTypeReadLocal: + + *(*int8)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4))) = int8(int32(0)) + + case WrappedFunctionTypeWriteLocal: + + *(*int8)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4))) = int8(int32(1)) + + case WrappedFunctionTypeReadRemote: + + *(*int8)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4))) = int8(int32(2)) + + case WrappedFunctionTypeWriteRemote: + + *(*int8)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4))) = int8(int32(3)) + + case WrappedFunctionTypeWriteRemoteBatched: + payload := (payload).DurableFunctionType.WriteRemoteBatched() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4))) = int8(int32(4)) + + switch payload.Tag() { + case witTypes.OptionNone: + *(*int8)(unsafe.Add(unsafe.Pointer(base), (128 + 4*4))) = int8(int32(0)) + + case witTypes.OptionSome: + payload := payload.Some() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (128 + 4*4))) = int8(int32(1)) + *(*int64)(unsafe.Add(unsafe.Pointer(base), (136 + 4*4))) = int64(payload) + + default: + panic("unreachable") + } + + case WrappedFunctionTypeWriteRemoteTransaction: + payload := (payload).DurableFunctionType.WriteRemoteTransaction() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (120 + 4*4))) = int8(int32(5)) + + switch payload.Tag() { + case witTypes.OptionNone: + *(*int8)(unsafe.Add(unsafe.Pointer(base), (128 + 4*4))) = int8(int32(0)) + + case witTypes.OptionSome: + payload := payload.Some() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (128 + 4*4))) = int8(int32(1)) + *(*int64)(unsafe.Add(unsafe.Pointer(base), (136 + 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 OplogEntryBeginRemoteTransaction: + payload := (element).F1.BeginRemoteTransaction() + *(*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) + 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(32)) + *(*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(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 OplogEntryCommittedRemoteTransaction: + payload := (element).F1.CommittedRemoteTransaction() + *(*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 OplogEntryRolledBackRemoteTransaction: + payload := (element).F1.RolledBackRemoteTransaction() + *(*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 OplogEntrySnapshot: + payload := (element).F1.Snapshot() + *(*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) + + 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(37)) + *(*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(38)) + *(*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(39)) + *(*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(40)) + *(*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(41)) + *(*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(42)) + *(*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(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) + + case OplogEntryCardExpired: + payload := (element).F1.CardExpired() + *(*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).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(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).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(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).StartIndex) + + case OplogEntryCompletionDelivered: + payload := (element).F1.CompletionDelivered() + *(*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 result2697 witTypes.Result[[]PublicOplogEntry, string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + result2695 := 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 variant2694 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: + + variant395 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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)))))) + + case 33: + + variant434 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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") + } + + variant2694 = 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 option440 witTypes.Option[golem_core_types.Uuid] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) { + case 0: + + option440 = witTypes.None[golem_core_types.Uuid]() + case 1: + + option440 = witTypes.Some[golem_core_types.Uuid](golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))))}) + default: + panic("unreachable") + } + var option441 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) { + case 0: + + option441 = witTypes.None[uint64]() + case 1: + + option441 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))))) + default: + panic("unreachable") + } + var option646 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 2*4)))) { + case 0: + + option646 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result617 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 3*4))))), index*(56+22*4)) + var variant605 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant605 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant605 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option448 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option448 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option443 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant442 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant442 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant442 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option443 = witTypes.Some[golem_core_types.NumericBound](variant442) + default: + panic("unreachable") + } + var option445 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option445 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant444 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant444 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant444 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant444 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option445 = witTypes.Some[golem_core_types.NumericBound](variant444) + default: + panic("unreachable") + } + var option447 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option447 = witTypes.None[string]() + case 1: + value446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option447 = witTypes.Some[string](value446) + default: + panic("unreachable") + } + + option448 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option443, option445, option447}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyS8Type(option448) + + case 3: + var option455 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option455 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option450 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant449 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant449 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant449 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option450 = witTypes.Some[golem_core_types.NumericBound](variant449) + default: + panic("unreachable") + } + var option452 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option452 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant451 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant451 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant451 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant451 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option452 = witTypes.Some[golem_core_types.NumericBound](variant451) + default: + panic("unreachable") + } + var option454 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option454 = witTypes.None[string]() + case 1: + value453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option454 = witTypes.Some[string](value453) + default: + panic("unreachable") + } + + option455 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option450, option452, option454}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyS16Type(option455) + + case 4: + var option462 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option462 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option457 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant456 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant456 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant456 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option457 = witTypes.Some[golem_core_types.NumericBound](variant456) + default: + panic("unreachable") + } + var option459 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option459 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant458 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant458 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant458 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant458 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option459 = witTypes.Some[golem_core_types.NumericBound](variant458) + default: + panic("unreachable") + } + var option461 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option461 = witTypes.None[string]() + case 1: + value460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option461 = witTypes.Some[string](value460) + default: + panic("unreachable") + } + + option462 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option457, option459, option461}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyS32Type(option462) + + case 5: + var option469 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option469 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option464 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant463 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant463 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant463 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option464 = witTypes.Some[golem_core_types.NumericBound](variant463) + default: + panic("unreachable") + } + var option466 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option466 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant465 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant465 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant465 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant465 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option466 = witTypes.Some[golem_core_types.NumericBound](variant465) + default: + panic("unreachable") + } + var option468 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option468 = witTypes.None[string]() + case 1: + value467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option468 = witTypes.Some[string](value467) + default: + panic("unreachable") + } + + option469 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option464, option466, option468}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyS64Type(option469) + + case 6: + var option476 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option476 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option471 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant470 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant470 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant470 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option471 = witTypes.Some[golem_core_types.NumericBound](variant470) + default: + panic("unreachable") + } + var option473 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option473 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant472 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant472 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant472 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant472 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option473 = witTypes.Some[golem_core_types.NumericBound](variant472) + default: + panic("unreachable") + } + var option475 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option475 = witTypes.None[string]() + case 1: + value474 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option475 = witTypes.Some[string](value474) + default: + panic("unreachable") + } + + option476 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option471, option473, option475}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyU8Type(option476) + + case 7: + var option483 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option483 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option478 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant477 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant477 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant477 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option478 = witTypes.Some[golem_core_types.NumericBound](variant477) + default: + panic("unreachable") + } + var option480 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option480 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant479 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant479 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant479 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant479 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option480 = witTypes.Some[golem_core_types.NumericBound](variant479) + default: + panic("unreachable") + } + var option482 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option482 = witTypes.None[string]() + case 1: + value481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option482 = witTypes.Some[string](value481) + default: + panic("unreachable") + } + + option483 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option478, option480, option482}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyU16Type(option483) + + case 8: + var option490 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option490 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option485 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant484 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant484 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant484 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option485 = witTypes.Some[golem_core_types.NumericBound](variant484) + default: + panic("unreachable") + } + var option487 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option487 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant486 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant486 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant486 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant486 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option487 = witTypes.Some[golem_core_types.NumericBound](variant486) + default: + panic("unreachable") + } + var option489 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option489 = witTypes.None[string]() + case 1: + value488 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option489 = witTypes.Some[string](value488) + default: + panic("unreachable") + } + + option490 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option485, option487, option489}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyU32Type(option490) + + case 9: + var option497 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option497 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option492 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant491 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant491 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant491 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option492 = witTypes.Some[golem_core_types.NumericBound](variant491) + default: + panic("unreachable") + } + var option494 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option494 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant493 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant493 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant493 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant493 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option494 = witTypes.Some[golem_core_types.NumericBound](variant493) + default: + panic("unreachable") + } + var option496 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option496 = witTypes.None[string]() + case 1: + value495 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option496 = witTypes.Some[string](value495) + default: + panic("unreachable") + } + + option497 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option492, option494, option496}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyU64Type(option497) + + case 10: + var option504 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option504 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option499 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant498 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant498 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant498 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option499 = witTypes.Some[golem_core_types.NumericBound](variant498) + default: + panic("unreachable") + } + var option501 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option501 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant500 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant500 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant500 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant500 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option501 = witTypes.Some[golem_core_types.NumericBound](variant500) + default: + panic("unreachable") + } + var option503 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option503 = witTypes.None[string]() + case 1: + value502 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option503 = witTypes.Some[string](value502) + default: + panic("unreachable") + } + + option504 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option499, option501, option503}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyF32Type(option504) + + case 11: + var option511 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option511 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option506 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant505 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant505 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant505 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option506 = witTypes.Some[golem_core_types.NumericBound](variant505) + default: + panic("unreachable") + } + var option508 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option508 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant507 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant507 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant507 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant507 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option508 = witTypes.Some[golem_core_types.NumericBound](variant507) + default: + panic("unreachable") + } + var option510 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option510 = witTypes.None[string]() + case 1: + value509 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option510 = witTypes.Some[string](value509) + default: + panic("unreachable") + } + + option511 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option506, option508, option510}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyF64Type(option511) + + case 12: + + variant605 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant605 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result524 := 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)) + value512 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option514 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option514 = witTypes.None[string]() + case 1: + value513 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option514 = witTypes.Some[string](value513) + default: + panic("unreachable") + } + result516 := 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)) + 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) + } + + result518 := 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)) + value517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result518 = append(result518, value517) + } + + var option520 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option520 = witTypes.None[string]() + case 1: + value519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option520 = witTypes.Some[string](value519) + default: + panic("unreachable") + } + var option523 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option523 = witTypes.None[golem_core_types.Role]() + case 1: + var variant522 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant522 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant522 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant522 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value521 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant522 = golem_core_types.MakeRoleOther(value521) + + default: + panic("unreachable") + } + + option523 = witTypes.Some[golem_core_types.Role](variant522) + default: + panic("unreachable") + } + + result524 = append(result524, golem_core_types.NamedFieldType{value512, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option514, result516, result518, option520, option523}}) + } + + variant605 = golem_core_types.MakeSchemaTypeBodyRecordType(result524) + + case 15: + result538 := 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)) + value525 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option526 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option526 = witTypes.None[int32]() + case 1: + + option526 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option528 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option528 = witTypes.None[string]() + case 1: + value527 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option528 = witTypes.Some[string](value527) + default: + panic("unreachable") + } + result530 := 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)) + 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) + } + + result532 := 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)) + value531 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result532 = append(result532, value531) + } + + var option534 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option534 = witTypes.None[string]() + case 1: + value533 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option534 = witTypes.Some[string](value533) + default: + panic("unreachable") + } + var option537 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option537 = witTypes.None[golem_core_types.Role]() + case 1: + var variant536 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant536 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant536 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant536 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value535 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant536 = golem_core_types.MakeRoleOther(value535) + + default: + panic("unreachable") + } + + option537 = witTypes.Some[golem_core_types.Role](variant536) + default: + panic("unreachable") + } + + result538 = append(result538, golem_core_types.VariantCaseType{value525, option526, golem_core_types.MetadataEnvelope{option528, result530, result532, option534, option537}}) + } + + variant605 = golem_core_types.MakeSchemaTypeBodyVariantType(result538) + + case 16: + 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) + } + + variant605 = golem_core_types.MakeSchemaTypeBodyEnumType(result540) + + case 17: + result542 := 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)) + value541 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result542 = append(result542, value541) + } + + variant605 = golem_core_types.MakeSchemaTypeBodyFlagsType(result542) + + case 18: + result543 := 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) + + result543 = append(result543, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant605 = golem_core_types.MakeSchemaTypeBodyTupleType(result543) + + case 19: + + variant605 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant605 = 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: + + variant605 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant605 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option544 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option544 = witTypes.None[int32]() + case 1: + + option544 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option545 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option545 = witTypes.None[int32]() + case 1: + + option545 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option544, option545}) + + case 24: + var option548 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option548 = witTypes.None[[]string]() + case 1: + result547 := 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)) + value546 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result547 = append(result547, value546) + } + + option548 = witTypes.Some[[]string](result547) + default: + panic("unreachable") + } + var option549 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option549 = witTypes.None[uint32]() + case 1: + + option549 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option550 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option550 = witTypes.None[uint32]() + case 1: + + option550 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option552 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option552 = witTypes.None[string]() + case 1: + value551 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option552 = witTypes.Some[string](value551) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option548, option549, option550, option552}) + + case 25: + var option555 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option555 = witTypes.None[[]string]() + case 1: + result554 := 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)) + value553 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result554 = append(result554, value553) + } + + option555 = witTypes.Some[[]string](result554) + default: + panic("unreachable") + } + var option556 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option556 = witTypes.None[uint32]() + case 1: + + option556 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option557 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option557 = witTypes.None[uint32]() + case 1: + + option557 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option555, option556, option557}) + + case 26: + var option560 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option560 = witTypes.None[[]string]() + case 1: + result559 := 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)) + value558 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result559 = append(result559, value558) + } + + option560 = witTypes.Some[[]string](result559) + default: + panic("unreachable") + } + var option563 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option563 = witTypes.None[[]string]() + case 1: + result562 := 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)) + value561 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result562 = append(result562, value561) + } + + option563 = witTypes.Some[[]string](result562) + default: + panic("unreachable") + } + + variant605 = 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)))), option560, option563}) + + case 27: + var option566 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option566 = witTypes.None[[]string]() + case 1: + result565 := 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)) + value564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result565 = append(result565, value564) + } + + option566 = witTypes.Some[[]string](result565) + default: + panic("unreachable") + } + var option569 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option569 = witTypes.None[[]string]() + case 1: + result568 := 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)) + value567 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result568 = append(result568, value567) + } + + option569 = witTypes.Some[[]string](result568) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option566, option569}) + + case 28: + + variant605 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant605 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value570 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result572 := 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)) + value571 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result572 = append(result572, value571) + } + + var option574 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option574 = 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))), value573}) + default: + panic("unreachable") + } + var option576 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option576 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value575 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option576 = 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))), value575}) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value570, result572, option574, option576}) + + case 31: + result598 := 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)) + value577 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant586 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant586 = golem_core_types.MakeDiscriminatorRulePrefix(value578) + + case 1: + value579 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant586 = golem_core_types.MakeDiscriminatorRuleSuffix(value579) + + case 2: + value580 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant586 = golem_core_types.MakeDiscriminatorRuleContains(value580) + + case 3: + value581 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant586 = golem_core_types.MakeDiscriminatorRuleRegex(value581) + + case 4: + value582 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option584 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option584 = witTypes.None[string]() + case 1: + value583 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option584 = witTypes.Some[string](value583) + default: + panic("unreachable") + } + + variant586 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value582, option584}) + + case 5: + value585 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant586 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value585) + + default: + panic("unreachable") + } + var option588 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option588 = witTypes.None[string]() + case 1: + value587 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option588 = witTypes.Some[string](value587) + default: + panic("unreachable") + } + result590 := 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)) + 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) + } + + result592 := 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)) + value591 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result592 = append(result592, value591) + } + + var option594 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option594 = witTypes.None[string]() + case 1: + value593 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option594 = witTypes.Some[string](value593) + default: + panic("unreachable") + } + var option597 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option597 = witTypes.None[golem_core_types.Role]() + case 1: + var variant596 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant596 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant596 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant596 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value595 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant596 = golem_core_types.MakeRoleOther(value595) + + default: + panic("unreachable") + } + + option597 = witTypes.Some[golem_core_types.Role](variant596) + default: + panic("unreachable") + } + + result598 = append(result598, golem_core_types.UnionBranch{value577, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant586, golem_core_types.MetadataEnvelope{option588, result590, result592, option594, option597}}) + } + + variant605 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result598}) + + case 32: + var option600 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option600 = witTypes.None[string]() + case 1: + value599 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option600 = witTypes.Some[string](value599) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option600}) + + case 33: + var option602 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option602 = witTypes.None[string]() + case 1: + value601 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option602 = witTypes.Some[string](value601) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option602}) + + case 34: + + variant605 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option603 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option603 = witTypes.None[int32]() + case 1: + + option603 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyFutureType(option603) + + case 36: + var option604 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option604 = witTypes.None[int32]() + case 1: + + option604 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant605 = golem_core_types.MakeSchemaTypeBodyStreamType(option604) + + default: + panic("unreachable") + } + var option607 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option607 = witTypes.None[string]() + case 1: + value606 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option607 = witTypes.Some[string](value606) + default: + panic("unreachable") + } + result609 := 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)) + 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) + } + + result611 := 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)) + value610 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result611 = append(result611, value610) + } + + var option613 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option613 = witTypes.None[string]() + case 1: + value612 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option613 = witTypes.Some[string](value612) + default: + panic("unreachable") + } + var option616 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option616 = witTypes.None[golem_core_types.Role]() + case 1: + var variant615 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant615 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant615 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant615 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value614 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant615 = golem_core_types.MakeRoleOther(value614) + + default: + panic("unreachable") + } + + option616 = witTypes.Some[golem_core_types.Role](variant615) + default: + panic("unreachable") + } + + result617 = append(result617, golem_core_types.SchemaTypeNode{variant605, golem_core_types.MetadataEnvelope{option607, result609, result611, option613, option616}}) + } + + result621 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 6*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 6*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 5*4))))), index*(6*4)) + value618 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option620 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option620 = witTypes.None[string]() + case 1: + value619 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option620 = witTypes.Some[string](value619) + default: + panic("unreachable") + } + + result621 = append(result621, golem_core_types.SchemaTypeDef{value618, option620, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result645 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 9*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 9*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 8*4))))), index*(16+4*4)) + var variant644 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant644 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant644 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant644 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant644 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant644 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant644 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant644 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant644 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant644 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant644 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant644 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant644 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant644 = golem_core_types.MakeSchemaValueNodeStringValue(value622) + + case 13: + result623 := 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) + + result623 = append(result623, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant644 = golem_core_types.MakeSchemaValueNodeRecordValue(result623) + + case 14: + var option624 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option624 = witTypes.None[int32]() + case 1: + + option624 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant644 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option624}) + + case 15: + + variant644 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result625 := 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) + + result625 = append(result625, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant644 = golem_core_types.MakeSchemaValueNodeFlagsValue(result625) + + case 17: + 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))) + } + + variant644 = golem_core_types.MakeSchemaValueNodeTupleValue(result626) + + case 18: + result627 := 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) + + result627 = append(result627, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant644 = golem_core_types.MakeSchemaValueNodeListValue(result627) + + case 19: + result628 := 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) + + result628 = append(result628, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant644 = golem_core_types.MakeSchemaValueNodeFixedListValue(result628) + + case 20: + result629 := 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) + + result629 = append(result629, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant644 = golem_core_types.MakeSchemaValueNodeMapValue(result629) + + case 21: + var option630 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option630 = witTypes.None[int32]() + case 1: + + option630 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant644 = golem_core_types.MakeSchemaValueNodeOptionValue(option630) + + case 22: + var variant633 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option631 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option631 = witTypes.None[int32]() + case 1: + + option631 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant633 = golem_core_types.MakeResultValuePayloadOkValue(option631) + + case 1: + var option632 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option632 = witTypes.None[int32]() + case 1: + + option632 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant633 = golem_core_types.MakeResultValuePayloadErrValue(option632) + + default: + panic("unreachable") + } + + variant644 = golem_core_types.MakeSchemaValueNodeResultValue(variant633) + + case 23: + value634 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option636 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option636 = witTypes.None[string]() + case 1: + value635 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option636 = witTypes.Some[string](value635) + default: + panic("unreachable") + } + + variant644 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value634, option636}) + + case 24: + value637 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option639 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option639 = witTypes.None[string]() + case 1: + value638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option639 = witTypes.Some[string](value638) + default: + panic("unreachable") + } + + variant644 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value637, option639}) + + case 25: + value640 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant644 = golem_core_types.MakeSchemaValueNodePathValue(value640) + + case 26: + value641 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant644 = golem_core_types.MakeSchemaValueNodeUrlValue(value641) + + case 27: + + variant644 = 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: + + variant644 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant644 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value642}) + + case 30: + value643 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant644 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value643, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant644 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant644 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant644 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result645 = append(result645, variant644) + } + + option646 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result617, result621, *(*int32)(unsafe.Add(unsafe.Pointer(base), (80 + 7*4)))}, golem_core_types.SchemaValueTree{result645, *(*int32)(unsafe.Add(unsafe.Pointer(base), (80 + 10*4)))}}) + default: + panic("unreachable") + } + var variant649 WrappedFunctionType + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 10*4)))) { + case 0: + + variant649 = MakeWrappedFunctionTypeReadLocal() + + case 1: + + variant649 = MakeWrappedFunctionTypeWriteLocal() + + case 2: + + variant649 = MakeWrappedFunctionTypeReadRemote() + + case 3: + + variant649 = MakeWrappedFunctionTypeWriteRemote() + + case 4: + var option647 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (96 + 10*4)))) { + case 0: + + option647 = witTypes.None[uint64]() + case 1: + + option647 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 10*4))))) + default: + panic("unreachable") + } + + variant649 = MakeWrappedFunctionTypeWriteRemoteBatched(option647) + + case 5: + var option648 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (96 + 10*4)))) { + case 0: + + option648 = witTypes.None[uint64]() + case 1: + + option648 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 10*4))))) + default: + panic("unreachable") + } + + variant649 = MakeWrappedFunctionTypeWriteRemoteTransaction(option648) + + default: + panic("unreachable") + } + + variant2694 = 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, option440, option441, option646, variant649}) + + case 2: + var option854 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + option854 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result825 := 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 variant813 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant813 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant813 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option656 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option656 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option651 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant650 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant650 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant650 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option651 = witTypes.Some[golem_core_types.NumericBound](variant650) + default: + panic("unreachable") + } + var option653 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant652 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant652 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant652 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option653 = witTypes.Some[golem_core_types.NumericBound](variant652) + default: + panic("unreachable") + } + var option655 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option655 = witTypes.None[string]() + case 1: + value654 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option655 = witTypes.Some[string](value654) + default: + panic("unreachable") + } + + option656 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option651, option653, option655}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyS8Type(option656) + + case 3: + var option663 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option663 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option658 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant657 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant657 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant657 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option658 = witTypes.Some[golem_core_types.NumericBound](variant657) + default: + panic("unreachable") + } + var option660 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant659 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant659 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant659 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option660 = witTypes.Some[golem_core_types.NumericBound](variant659) + default: + panic("unreachable") + } + var option662 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option662 = witTypes.None[string]() + case 1: + value661 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option662 = witTypes.Some[string](value661) + default: + panic("unreachable") + } + + option663 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option658, option660, option662}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyS16Type(option663) + + case 4: + var option670 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option670 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option665 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant664 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant664 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant664 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option665 = witTypes.Some[golem_core_types.NumericBound](variant664) + default: + panic("unreachable") + } + var option667 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant666 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant666 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant666 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option667 = witTypes.Some[golem_core_types.NumericBound](variant666) + default: + panic("unreachable") + } + var option669 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option669 = witTypes.None[string]() + case 1: + value668 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option669 = witTypes.Some[string](value668) + default: + panic("unreachable") + } + + option670 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option665, option667, option669}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyS32Type(option670) + + case 5: + var option677 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option677 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option672 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant671 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant671 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant671 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option672 = witTypes.Some[golem_core_types.NumericBound](variant671) + default: + panic("unreachable") + } + var option674 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant673 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant673 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant673 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option674 = witTypes.Some[golem_core_types.NumericBound](variant673) + default: + panic("unreachable") + } + var option676 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option676 = witTypes.None[string]() + case 1: + value675 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option676 = witTypes.Some[string](value675) + default: + panic("unreachable") + } + + option677 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option672, option674, option676}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyS64Type(option677) + + case 6: + var option684 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option684 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option679 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant678 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant678 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant678 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option679 = witTypes.Some[golem_core_types.NumericBound](variant678) + default: + panic("unreachable") + } + var option681 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant680 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant680 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant680 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option681 = witTypes.Some[golem_core_types.NumericBound](variant680) + default: + panic("unreachable") + } + var option683 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option683 = witTypes.None[string]() + case 1: + value682 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option683 = witTypes.Some[string](value682) + default: + panic("unreachable") + } + + option684 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option679, option681, option683}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyU8Type(option684) + + case 7: + var option691 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option691 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option686 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant685 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant685 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant685 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option686 = witTypes.Some[golem_core_types.NumericBound](variant685) + default: + panic("unreachable") + } + var option688 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant687 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant687 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant687 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option688 = witTypes.Some[golem_core_types.NumericBound](variant687) + default: + panic("unreachable") + } + var option690 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option690 = witTypes.None[string]() + case 1: + value689 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option690 = witTypes.Some[string](value689) + default: + panic("unreachable") + } + + option691 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option686, option688, option690}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyU16Type(option691) + + case 8: + var option698 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option698 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option693 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant692 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant692 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant692 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option693 = witTypes.Some[golem_core_types.NumericBound](variant692) + default: + panic("unreachable") + } + var option695 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant694 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant694 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant694 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option695 = witTypes.Some[golem_core_types.NumericBound](variant694) + default: + panic("unreachable") + } + var option697 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option697 = witTypes.None[string]() + case 1: + value696 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option697 = witTypes.Some[string](value696) + default: + panic("unreachable") + } + + option698 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option693, option695, option697}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyU32Type(option698) + + case 9: + var option705 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option705 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option700 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant699 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant699 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant699 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option700 = witTypes.Some[golem_core_types.NumericBound](variant699) + default: + panic("unreachable") + } + var option702 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option702 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant701 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant701 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant701 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant701 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option702 = witTypes.Some[golem_core_types.NumericBound](variant701) + default: + panic("unreachable") + } + var option704 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option704 = witTypes.None[string]() + case 1: + value703 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option704 = witTypes.Some[string](value703) + default: + panic("unreachable") + } + + option705 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option700, option702, option704}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyU64Type(option705) + + case 10: + var option712 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option712 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option707 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant706 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant706 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant706 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option707 = witTypes.Some[golem_core_types.NumericBound](variant706) + default: + panic("unreachable") + } + var option709 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option709 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant708 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant708 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant708 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant708 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option709 = witTypes.Some[golem_core_types.NumericBound](variant708) + default: + panic("unreachable") + } + var option711 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option711 = witTypes.None[string]() + case 1: + value710 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option711 = witTypes.Some[string](value710) + default: + panic("unreachable") + } + + option712 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option707, option709, option711}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyF32Type(option712) + + case 11: + var option719 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option719 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option714 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant713 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant713 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant713 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option714 = witTypes.Some[golem_core_types.NumericBound](variant713) + default: + panic("unreachable") + } + var option716 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option716 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant715 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant715 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant715 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant715 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option716 = witTypes.Some[golem_core_types.NumericBound](variant715) + default: + panic("unreachable") + } + var option718 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option718 = witTypes.None[string]() + case 1: + value717 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option718 = witTypes.Some[string](value717) + default: + panic("unreachable") + } + + option719 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option714, option716, option718}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyF64Type(option719) + + case 12: + + variant813 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant813 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result732 := 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)) + value720 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option722 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option722 = witTypes.None[string]() + case 1: + value721 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option722 = witTypes.Some[string](value721) + default: + panic("unreachable") + } + result724 := 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)) + 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) + } + + result726 := 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)) + value725 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result726 = append(result726, value725) + } + + var option728 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option728 = witTypes.None[string]() + case 1: + value727 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option728 = witTypes.Some[string](value727) + default: + panic("unreachable") + } + var option731 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option731 = witTypes.None[golem_core_types.Role]() + case 1: + var variant730 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant730 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant730 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant730 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value729 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant730 = golem_core_types.MakeRoleOther(value729) + + default: + panic("unreachable") + } + + option731 = witTypes.Some[golem_core_types.Role](variant730) + default: + panic("unreachable") + } + + result732 = append(result732, golem_core_types.NamedFieldType{value720, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option722, result724, result726, option728, option731}}) + } + + variant813 = golem_core_types.MakeSchemaTypeBodyRecordType(result732) + + case 15: + result746 := 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)) + value733 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option734 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option734 = witTypes.None[int32]() + case 1: + + option734 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option736 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option736 = witTypes.None[string]() + case 1: + value735 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option736 = witTypes.Some[string](value735) + default: + panic("unreachable") + } + result738 := 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)) + 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) + } + + result740 := 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)) + value739 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result740 = append(result740, value739) + } + + var option742 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option742 = witTypes.None[string]() + case 1: + value741 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option742 = witTypes.Some[string](value741) + default: + panic("unreachable") + } + var option745 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option745 = witTypes.None[golem_core_types.Role]() + case 1: + var variant744 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant744 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant744 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant744 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value743 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant744 = golem_core_types.MakeRoleOther(value743) + + default: + panic("unreachable") + } + + option745 = witTypes.Some[golem_core_types.Role](variant744) + default: + panic("unreachable") + } + + result746 = append(result746, golem_core_types.VariantCaseType{value733, option734, golem_core_types.MetadataEnvelope{option736, result738, result740, option742, option745}}) + } + + variant813 = golem_core_types.MakeSchemaTypeBodyVariantType(result746) + + case 16: + 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) + } + + variant813 = golem_core_types.MakeSchemaTypeBodyEnumType(result748) + + case 17: + result750 := 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)) + value749 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result750 = append(result750, value749) + } + + variant813 = golem_core_types.MakeSchemaTypeBodyFlagsType(result750) + + case 18: + result751 := 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) + + result751 = append(result751, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant813 = golem_core_types.MakeSchemaTypeBodyTupleType(result751) + + case 19: + + variant813 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant813 = 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: + + variant813 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant813 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option752 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option752 = witTypes.None[int32]() + case 1: + + option752 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option753 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option753 = witTypes.None[int32]() + case 1: + + option753 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option752, option753}) + + case 24: + var option756 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option756 = witTypes.None[[]string]() + case 1: + result755 := 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)) + value754 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result755 = append(result755, value754) + } + + option756 = witTypes.Some[[]string](result755) + default: + panic("unreachable") + } + var option757 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option757 = witTypes.None[uint32]() + case 1: + + option757 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option758 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option758 = witTypes.None[uint32]() + case 1: + + option758 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option760 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option760 = witTypes.None[string]() + case 1: + value759 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option760 = witTypes.Some[string](value759) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option756, option757, option758, option760}) + + case 25: + var option763 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option763 = witTypes.None[[]string]() + case 1: + result762 := 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)) + value761 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result762 = append(result762, value761) + } + + option763 = witTypes.Some[[]string](result762) + default: + panic("unreachable") + } + var option764 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option764 = witTypes.None[uint32]() + case 1: + + option764 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option765 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option765 = witTypes.None[uint32]() + case 1: + + option765 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option763, option764, option765}) + + case 26: + var option768 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option768 = witTypes.None[[]string]() + case 1: + result767 := 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)) + value766 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result767 = append(result767, value766) + } + + option768 = witTypes.Some[[]string](result767) + default: + panic("unreachable") + } + var option771 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option771 = witTypes.None[[]string]() + case 1: + result770 := 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)) + value769 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result770 = append(result770, value769) + } + + option771 = witTypes.Some[[]string](result770) + default: + panic("unreachable") + } + + variant813 = 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)))), option768, option771}) + + case 27: + var option774 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option774 = witTypes.None[[]string]() + case 1: + result773 := 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)) + value772 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result773 = append(result773, value772) + } + + option774 = witTypes.Some[[]string](result773) + default: + panic("unreachable") + } + var option777 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option777 = witTypes.None[[]string]() + case 1: + result776 := 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)) + value775 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result776 = append(result776, value775) + } + + option777 = witTypes.Some[[]string](result776) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option774, option777}) + + case 28: + + variant813 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant813 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result780 := 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)) + value779 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result780 = append(result780, value779) + } + + var option782 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option782 = 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))), value781}) + default: + panic("unreachable") + } + var option784 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option784 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value783 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option784 = 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))), value783}) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value778, result780, option782, option784}) + + case 31: + result806 := 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)) + value785 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant794 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant794 = golem_core_types.MakeDiscriminatorRulePrefix(value786) + + case 1: + value787 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant794 = golem_core_types.MakeDiscriminatorRuleSuffix(value787) + + case 2: + value788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant794 = golem_core_types.MakeDiscriminatorRuleContains(value788) + + case 3: + value789 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant794 = golem_core_types.MakeDiscriminatorRuleRegex(value789) + + case 4: + value790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option792 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option792 = witTypes.None[string]() + case 1: + value791 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option792 = witTypes.Some[string](value791) + default: + panic("unreachable") + } + + variant794 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value790, option792}) + + case 5: + value793 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant794 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value793) + + default: + panic("unreachable") + } + var option796 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option796 = witTypes.None[string]() + case 1: + value795 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option796 = witTypes.Some[string](value795) + default: + panic("unreachable") + } + result798 := 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)) + 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), (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)) + 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), (16 * 4)))) { + case 0: + + option802 = witTypes.None[string]() + case 1: + value801 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 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), (19 * 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), (20 * 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), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 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.UnionBranch{value785, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant794, golem_core_types.MetadataEnvelope{option796, result798, result800, option802, option805}}) + } + + variant813 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result806}) + + case 32: + var option808 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option808 = witTypes.None[string]() + case 1: + value807 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option808 = witTypes.Some[string](value807) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option808}) + + case 33: + var option810 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option810 = witTypes.None[string]() + case 1: + value809 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option810 = witTypes.Some[string](value809) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option810}) + + case 34: + + variant813 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option811 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option811 = witTypes.None[int32]() + case 1: + + option811 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyFutureType(option811) + + case 36: + var option812 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option812 = witTypes.None[int32]() + case 1: + + option812 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant813 = golem_core_types.MakeSchemaTypeBodyStreamType(option812) + + default: + panic("unreachable") + } + var option815 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option815 = witTypes.None[string]() + case 1: + value814 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option815 = witTypes.Some[string](value814) + default: + panic("unreachable") + } + result817 := 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)) + 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) + } + + result819 := 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)) + value818 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result819 = append(result819, value818) + } + + var option821 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option821 = witTypes.None[string]() + case 1: + value820 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option821 = witTypes.Some[string](value820) + default: + panic("unreachable") + } + var option824 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option824 = witTypes.None[golem_core_types.Role]() + case 1: + var variant823 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant823 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant823 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant823 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value822 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant823 = golem_core_types.MakeRoleOther(value822) + + default: + panic("unreachable") + } + + option824 = witTypes.Some[golem_core_types.Role](variant823) + default: + panic("unreachable") + } + + result825 = append(result825, golem_core_types.SchemaTypeNode{variant813, golem_core_types.MetadataEnvelope{option815, result817, result819, option821, option824}}) + } + + result829 := 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)) + value826 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option828 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option828 = witTypes.None[string]() + case 1: + value827 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option828 = witTypes.Some[string](value827) + default: + panic("unreachable") + } + + result829 = append(result829, golem_core_types.SchemaTypeDef{value826, option828, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result853 := 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 variant852 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant852 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant852 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant852 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant852 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant852 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant852 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant852 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant852 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant852 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant852 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant852 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant852 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value830 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant852 = golem_core_types.MakeSchemaValueNodeStringValue(value830) + + case 13: + result831 := 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) + + result831 = append(result831, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant852 = golem_core_types.MakeSchemaValueNodeRecordValue(result831) + + case 14: + var option832 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option832 = witTypes.None[int32]() + case 1: + + option832 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant852 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option832}) + + case 15: + + variant852 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result833 := 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) + + result833 = append(result833, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant852 = golem_core_types.MakeSchemaValueNodeFlagsValue(result833) + + case 17: + 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))) + } + + variant852 = golem_core_types.MakeSchemaValueNodeTupleValue(result834) + + case 18: + result835 := 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) + + result835 = append(result835, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant852 = golem_core_types.MakeSchemaValueNodeListValue(result835) + + case 19: + result836 := 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) + + result836 = append(result836, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant852 = golem_core_types.MakeSchemaValueNodeFixedListValue(result836) + + case 20: + result837 := 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) + + result837 = append(result837, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant852 = golem_core_types.MakeSchemaValueNodeMapValue(result837) + + case 21: + var option838 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option838 = witTypes.None[int32]() + case 1: + + option838 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant852 = golem_core_types.MakeSchemaValueNodeOptionValue(option838) + + case 22: + var variant841 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option839 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option839 = witTypes.None[int32]() + case 1: + + option839 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant841 = golem_core_types.MakeResultValuePayloadOkValue(option839) + + case 1: + var option840 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option840 = witTypes.None[int32]() + case 1: + + option840 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant841 = golem_core_types.MakeResultValuePayloadErrValue(option840) + + default: + panic("unreachable") + } + + variant852 = golem_core_types.MakeSchemaValueNodeResultValue(variant841) + + case 23: + value842 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option844 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option844 = witTypes.None[string]() + case 1: + value843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option844 = witTypes.Some[string](value843) + default: + panic("unreachable") + } + + variant852 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value842, option844}) + + case 24: + value845 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option847 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option847 = witTypes.None[string]() + case 1: + value846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option847 = witTypes.Some[string](value846) + default: + panic("unreachable") + } + + variant852 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value845, option847}) + + case 25: + value848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant852 = golem_core_types.MakeSchemaValueNodePathValue(value848) + + case 26: + value849 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant852 = golem_core_types.MakeSchemaValueNodeUrlValue(value849) + + case 27: + + variant852 = 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: + + variant852 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant852 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value850}) + + case 30: + value851 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant852 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value851, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant852 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant852 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant852 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result853 = append(result853, variant852) + } + + option854 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result825, result829, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result853, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}) + default: + panic("unreachable") + } + + variant2694 = 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))), option854, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))) != 0)}) + + case 3: + var option1059 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + option1059 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result1030 := 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 variant1018 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1018 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1018 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option861 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option861 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option856 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant855 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant855 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant855 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option856 = witTypes.Some[golem_core_types.NumericBound](variant855) + default: + panic("unreachable") + } + var option858 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option858 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant857 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant857 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant857 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant857 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option858 = witTypes.Some[golem_core_types.NumericBound](variant857) + default: + panic("unreachable") + } + var option860 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option860 = witTypes.None[string]() + case 1: + value859 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option860 = witTypes.Some[string](value859) + default: + panic("unreachable") + } + + option861 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option856, option858, option860}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyS8Type(option861) + + case 3: + var option868 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option868 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option863 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant862 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant862 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant862 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option863 = witTypes.Some[golem_core_types.NumericBound](variant862) + default: + panic("unreachable") + } + var option865 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option865 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant864 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant864 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant864 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant864 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option865 = witTypes.Some[golem_core_types.NumericBound](variant864) + default: + panic("unreachable") + } + var option867 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option867 = witTypes.None[string]() + case 1: + value866 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option867 = witTypes.Some[string](value866) + default: + panic("unreachable") + } + + option868 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option863, option865, option867}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyS16Type(option868) + + case 4: + var option875 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option875 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option870 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant869 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant869 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant869 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option870 = witTypes.Some[golem_core_types.NumericBound](variant869) + default: + panic("unreachable") + } + var option872 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option872 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant871 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant871 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant871 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant871 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option872 = witTypes.Some[golem_core_types.NumericBound](variant871) + default: + panic("unreachable") + } + var option874 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option874 = witTypes.None[string]() + case 1: + value873 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option874 = witTypes.Some[string](value873) + default: + panic("unreachable") + } + + option875 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option870, option872, option874}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyS32Type(option875) + + case 5: + var option882 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option882 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option877 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant876 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant876 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant876 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option877 = witTypes.Some[golem_core_types.NumericBound](variant876) + default: + panic("unreachable") + } + var option879 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option879 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant878 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant878 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant878 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant878 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option879 = witTypes.Some[golem_core_types.NumericBound](variant878) + default: + panic("unreachable") + } + var option881 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option881 = witTypes.None[string]() + case 1: + value880 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option881 = witTypes.Some[string](value880) + default: + panic("unreachable") + } + + option882 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option877, option879, option881}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyS64Type(option882) + + case 6: + var option889 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option889 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option884 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant883 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant883 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant883 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option884 = witTypes.Some[golem_core_types.NumericBound](variant883) + default: + panic("unreachable") + } + var option886 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option886 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant885 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant885 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant885 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant885 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option886 = witTypes.Some[golem_core_types.NumericBound](variant885) + default: + panic("unreachable") + } + var option888 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option888 = witTypes.None[string]() + case 1: + value887 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option888 = witTypes.Some[string](value887) + default: + panic("unreachable") + } + + option889 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option884, option886, option888}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyU8Type(option889) + + case 7: + var option896 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option896 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option891 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant890 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant890 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant890 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option891 = witTypes.Some[golem_core_types.NumericBound](variant890) + default: + panic("unreachable") + } + var option893 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option893 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant892 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant892 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant892 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant892 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option893 = witTypes.Some[golem_core_types.NumericBound](variant892) + default: + panic("unreachable") + } + var option895 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option895 = witTypes.None[string]() + case 1: + value894 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option895 = witTypes.Some[string](value894) + default: + panic("unreachable") + } + + option896 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option891, option893, option895}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyU16Type(option896) + + case 8: + var option903 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option903 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option898 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant897 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant897 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant897 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option898 = witTypes.Some[golem_core_types.NumericBound](variant897) + default: + panic("unreachable") + } + var option900 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option900 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant899 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant899 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant899 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant899 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option900 = witTypes.Some[golem_core_types.NumericBound](variant899) + default: + panic("unreachable") + } + var option902 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option902 = witTypes.None[string]() + case 1: + value901 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option902 = witTypes.Some[string](value901) + default: + panic("unreachable") + } + + option903 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option898, option900, option902}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyU32Type(option903) + + case 9: + var option910 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option910 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option905 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant904 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant904 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant904 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option905 = witTypes.Some[golem_core_types.NumericBound](variant904) + default: + panic("unreachable") + } + var option907 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option907 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant906 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant906 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant906 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant906 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option907 = witTypes.Some[golem_core_types.NumericBound](variant906) + default: + panic("unreachable") + } + var option909 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option909 = witTypes.None[string]() + case 1: + value908 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option909 = witTypes.Some[string](value908) + default: + panic("unreachable") + } + + option910 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option905, option907, option909}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyU64Type(option910) + + case 10: + var option917 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option917 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option912 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant911 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant911 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant911 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option912 = witTypes.Some[golem_core_types.NumericBound](variant911) + default: + panic("unreachable") + } + var option914 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option914 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant913 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant913 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant913 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant913 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option914 = witTypes.Some[golem_core_types.NumericBound](variant913) + default: + panic("unreachable") + } + var option916 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option916 = witTypes.None[string]() + case 1: + value915 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option916 = witTypes.Some[string](value915) + default: + panic("unreachable") + } + + option917 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option912, option914, option916}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyF32Type(option917) + + case 11: + var option924 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option924 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option919 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant918 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant918 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant918 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option919 = witTypes.Some[golem_core_types.NumericBound](variant918) + default: + panic("unreachable") + } + var option921 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option921 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant920 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant920 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant920 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant920 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option921 = witTypes.Some[golem_core_types.NumericBound](variant920) + default: + panic("unreachable") + } + var option923 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option923 = witTypes.None[string]() + case 1: + value922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option923 = witTypes.Some[string](value922) + default: + panic("unreachable") + } + + option924 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option919, option921, option923}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyF64Type(option924) + + case 12: + + variant1018 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1018 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result937 := 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)) + value925 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option927 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option927 = witTypes.None[string]() + case 1: + value926 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option927 = witTypes.Some[string](value926) + default: + panic("unreachable") + } + result929 := 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)) + 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) + } + + result931 := 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)) + value930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result931 = append(result931, value930) + } + + var option933 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option933 = witTypes.None[string]() + case 1: + value932 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option933 = witTypes.Some[string](value932) + default: + panic("unreachable") + } + var option936 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option936 = witTypes.None[golem_core_types.Role]() + case 1: + var variant935 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant935 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant935 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant935 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value934 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant935 = golem_core_types.MakeRoleOther(value934) + + default: + panic("unreachable") + } + + option936 = witTypes.Some[golem_core_types.Role](variant935) + default: + panic("unreachable") + } + + result937 = append(result937, golem_core_types.NamedFieldType{value925, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option927, result929, result931, option933, option936}}) + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyRecordType(result937) + + case 15: + result951 := 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)) + value938 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option939 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option939 = witTypes.None[int32]() + case 1: + + option939 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option941 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option941 = witTypes.None[string]() + case 1: + value940 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option941 = witTypes.Some[string](value940) + default: + panic("unreachable") + } + result943 := 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)) + 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) + } + + result945 := 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)) + value944 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result945 = append(result945, value944) + } + + var option947 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option947 = witTypes.None[string]() + case 1: + value946 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option947 = witTypes.Some[string](value946) + default: + panic("unreachable") + } + var option950 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option950 = witTypes.None[golem_core_types.Role]() + case 1: + var variant949 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant949 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant949 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant949 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value948 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant949 = golem_core_types.MakeRoleOther(value948) + + default: + panic("unreachable") + } + + option950 = witTypes.Some[golem_core_types.Role](variant949) + default: + panic("unreachable") + } + + result951 = append(result951, golem_core_types.VariantCaseType{value938, option939, golem_core_types.MetadataEnvelope{option941, result943, result945, option947, option950}}) + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyVariantType(result951) + + case 16: + 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) + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyEnumType(result953) + + case 17: + result955 := 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)) + value954 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result955 = append(result955, value954) + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyFlagsType(result955) + + case 18: + result956 := 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) + + result956 = append(result956, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyTupleType(result956) + + case 19: + + variant1018 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1018 = 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: + + variant1018 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1018 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option957 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option957 = witTypes.None[int32]() + case 1: + + option957 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option958 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option958 = witTypes.None[int32]() + case 1: + + option958 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option957, option958}) + + case 24: + 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 option962 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option962 = witTypes.None[uint32]() + case 1: + + option962 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option963 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option963 = witTypes.None[uint32]() + case 1: + + option963 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option965 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option965 = witTypes.None[string]() + case 1: + value964 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option965 = witTypes.Some[string](value964) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option961, option962, option963, option965}) + + case 25: + var option968 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option968 = witTypes.None[[]string]() + case 1: + result967 := 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)) + 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) + } + + option968 = witTypes.Some[[]string](result967) + default: + panic("unreachable") + } + var option969 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option969 = witTypes.None[uint32]() + case 1: + + option969 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option970 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option970 = witTypes.None[uint32]() + case 1: + + option970 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option968, option969, option970}) + + case 26: + var option973 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option973 = witTypes.None[[]string]() + case 1: + result972 := 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)) + value971 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result972 = append(result972, value971) + } + + option973 = witTypes.Some[[]string](result972) + default: + panic("unreachable") + } + var option976 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option976 = witTypes.None[[]string]() + case 1: + result975 := 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)) + value974 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result975 = append(result975, value974) + } + + option976 = witTypes.Some[[]string](result975) + default: + panic("unreachable") + } + + variant1018 = 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)))), option973, option976}) + + case 27: + var option979 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option979 = witTypes.None[[]string]() + case 1: + result978 := 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)) + value977 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result978 = append(result978, value977) + } + + option979 = witTypes.Some[[]string](result978) + default: + panic("unreachable") + } + var option982 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option982 = witTypes.None[[]string]() + case 1: + result981 := 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)) + value980 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result981 = append(result981, value980) + } + + option982 = witTypes.Some[[]string](result981) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option979, option982}) + + case 28: + + variant1018 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1018 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value983 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result985 := 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)) + 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) + } + + var option987 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option987 = 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))), value986}) + default: + panic("unreachable") + } + var option989 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option989 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value988 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option989 = 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))), value988}) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value983, result985, option987, option989}) + + case 31: + result1011 := 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)) + value990 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant999 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value991 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant999 = golem_core_types.MakeDiscriminatorRulePrefix(value991) + + case 1: + value992 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant999 = golem_core_types.MakeDiscriminatorRuleSuffix(value992) + + case 2: + value993 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant999 = golem_core_types.MakeDiscriminatorRuleContains(value993) + + case 3: + value994 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant999 = golem_core_types.MakeDiscriminatorRuleRegex(value994) + + case 4: + value995 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option997 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option997 = witTypes.None[string]() + case 1: + value996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option997 = witTypes.Some[string](value996) + default: + panic("unreachable") + } + + variant999 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value995, option997}) + + case 5: + value998 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant999 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value998) + + default: + panic("unreachable") + } + var option1001 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1001 = witTypes.None[string]() + case 1: + value1000 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1001 = witTypes.Some[string](value1000) + default: + panic("unreachable") + } + result1003 := 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)) + 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) + } + + result1005 := 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)) + value1004 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1005 = append(result1005, value1004) + } + + var option1007 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1007 = witTypes.None[string]() + case 1: + value1006 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1007 = witTypes.Some[string](value1006) + default: + panic("unreachable") + } + var option1010 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1010 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1009 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1009 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1009 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1009 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1008 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1009 = golem_core_types.MakeRoleOther(value1008) + + default: + panic("unreachable") + } + + option1010 = witTypes.Some[golem_core_types.Role](variant1009) + default: + panic("unreachable") + } + + result1011 = append(result1011, golem_core_types.UnionBranch{value990, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant999, golem_core_types.MetadataEnvelope{option1001, result1003, result1005, option1007, option1010}}) + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1011}) + + case 32: + var option1013 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1013 = witTypes.None[string]() + case 1: + value1012 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1013 = witTypes.Some[string](value1012) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1013}) + + case 33: + var option1015 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1015 = witTypes.None[string]() + case 1: + value1014 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1015 = witTypes.Some[string](value1014) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1015}) + + case 34: + + variant1018 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1016 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1016 = witTypes.None[int32]() + case 1: + + option1016 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyFutureType(option1016) + + case 36: + var option1017 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1017 = witTypes.None[int32]() + case 1: + + option1017 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1018 = golem_core_types.MakeSchemaTypeBodyStreamType(option1017) + + default: + panic("unreachable") + } + var option1020 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1020 = witTypes.None[string]() + case 1: + value1019 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1020 = witTypes.Some[string](value1019) + default: + panic("unreachable") + } + result1022 := 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)) + 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) + } + + result1024 := 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)) + value1023 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1024 = append(result1024, value1023) + } + + var option1026 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1026 = witTypes.None[string]() + case 1: + value1025 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1026 = witTypes.Some[string](value1025) + default: + panic("unreachable") + } + var option1029 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1029 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1028 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1028 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1028 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1028 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1027 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1028 = golem_core_types.MakeRoleOther(value1027) + + default: + panic("unreachable") + } + + option1029 = witTypes.Some[golem_core_types.Role](variant1028) + default: + panic("unreachable") + } + + result1030 = append(result1030, golem_core_types.SchemaTypeNode{variant1018, golem_core_types.MetadataEnvelope{option1020, result1022, result1024, option1026, option1029}}) + } + + result1034 := 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)) + value1031 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1033 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1033 = witTypes.None[string]() + case 1: + value1032 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1033 = witTypes.Some[string](value1032) + default: + panic("unreachable") + } + + result1034 = append(result1034, golem_core_types.SchemaTypeDef{value1031, option1033, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1058 := 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 variant1057 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1057 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1057 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1057 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1057 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1057 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1057 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1057 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1057 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1057 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1057 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1057 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1057 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1057 = golem_core_types.MakeSchemaValueNodeStringValue(value1035) + + case 13: + result1036 := 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) + + result1036 = append(result1036, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1057 = golem_core_types.MakeSchemaValueNodeRecordValue(result1036) + + case 14: + var option1037 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1037 = witTypes.None[int32]() + case 1: + + option1037 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1057 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1037}) + + case 15: + + variant1057 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1038 := 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) + + result1038 = append(result1038, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1057 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1038) + + case 17: + 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))) + } + + variant1057 = golem_core_types.MakeSchemaValueNodeTupleValue(result1039) + + case 18: + result1040 := 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) + + result1040 = append(result1040, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1057 = golem_core_types.MakeSchemaValueNodeListValue(result1040) + + case 19: + result1041 := 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) + + result1041 = append(result1041, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1057 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1041) + + case 20: + result1042 := 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) + + result1042 = append(result1042, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1057 = golem_core_types.MakeSchemaValueNodeMapValue(result1042) + + case 21: + var option1043 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1043 = witTypes.None[int32]() + case 1: + + option1043 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1057 = golem_core_types.MakeSchemaValueNodeOptionValue(option1043) + + case 22: + var variant1046 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1044 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1044 = witTypes.None[int32]() + case 1: + + option1044 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1046 = golem_core_types.MakeResultValuePayloadOkValue(option1044) + + case 1: + var option1045 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1045 = witTypes.None[int32]() + case 1: + + option1045 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1046 = golem_core_types.MakeResultValuePayloadErrValue(option1045) + + default: + panic("unreachable") + } + + variant1057 = golem_core_types.MakeSchemaValueNodeResultValue(variant1046) + + case 23: + value1047 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1049 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1049 = witTypes.None[string]() + case 1: + value1048 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1049 = witTypes.Some[string](value1048) + default: + panic("unreachable") + } + + variant1057 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1047, option1049}) + + case 24: + value1050 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1052 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1052 = witTypes.None[string]() + case 1: + value1051 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1052 = witTypes.Some[string](value1051) + default: + panic("unreachable") + } + + variant1057 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1050, option1052}) + + case 25: + value1053 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1057 = golem_core_types.MakeSchemaValueNodePathValue(value1053) + + case 26: + value1054 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1057 = golem_core_types.MakeSchemaValueNodeUrlValue(value1054) + + case 27: + + variant1057 = 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: + + variant1057 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1055 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1057 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1055}) + + case 30: + value1056 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1057 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1056, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1057 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1057 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1057 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1058 = append(result1058, variant1057) + } + + option1059 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1030, result1034, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result1058, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}) + default: + panic("unreachable") + } + + variant2694 = 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))), option1059}) + + case 4: + var variant1504 AgentInvocation + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + value1060 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + result1236 := 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 variant1224 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1224 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1224 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1067 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1067 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1062 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1061 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1061 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1061 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1062 = witTypes.Some[golem_core_types.NumericBound](variant1061) + default: + panic("unreachable") + } + var option1064 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1064 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1063 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1063 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1063 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1063 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1064 = witTypes.Some[golem_core_types.NumericBound](variant1063) + default: + panic("unreachable") + } + var option1066 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1066 = witTypes.None[string]() + case 1: + value1065 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1066 = witTypes.Some[string](value1065) + default: + panic("unreachable") + } + + option1067 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1062, option1064, option1066}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyS8Type(option1067) + + case 3: + var option1074 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1074 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1069 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1068 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1068 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1068 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1069 = witTypes.Some[golem_core_types.NumericBound](variant1068) + default: + panic("unreachable") + } + var option1071 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1071 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1070 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1070 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1070 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1070 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1071 = witTypes.Some[golem_core_types.NumericBound](variant1070) + default: + panic("unreachable") + } + var option1073 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1073 = witTypes.None[string]() + case 1: + value1072 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1073 = witTypes.Some[string](value1072) + default: + panic("unreachable") + } + + option1074 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1069, option1071, option1073}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyS16Type(option1074) + + case 4: + var option1081 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1081 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1076 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1075 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1075 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1075 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1076 = witTypes.Some[golem_core_types.NumericBound](variant1075) + default: + panic("unreachable") + } + var option1078 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1078 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1077 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1077 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1077 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1077 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1078 = witTypes.Some[golem_core_types.NumericBound](variant1077) + default: + panic("unreachable") + } + var option1080 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1080 = witTypes.None[string]() + case 1: + value1079 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1080 = witTypes.Some[string](value1079) + default: + panic("unreachable") + } + + option1081 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1076, option1078, option1080}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyS32Type(option1081) + + case 5: + var option1088 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1088 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1083 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1082 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1082 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1082 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1083 = witTypes.Some[golem_core_types.NumericBound](variant1082) + default: + panic("unreachable") + } + var option1085 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1085 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1084 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1084 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1084 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1084 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1085 = witTypes.Some[golem_core_types.NumericBound](variant1084) + default: + panic("unreachable") + } + var option1087 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1087 = witTypes.None[string]() + case 1: + value1086 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1087 = witTypes.Some[string](value1086) + default: + panic("unreachable") + } + + option1088 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1083, option1085, option1087}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyS64Type(option1088) + + case 6: + var option1095 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1095 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1090 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1089 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1089 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1089 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1090 = witTypes.Some[golem_core_types.NumericBound](variant1089) + default: + panic("unreachable") + } + var option1092 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1092 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1091 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1091 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1091 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1091 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1092 = witTypes.Some[golem_core_types.NumericBound](variant1091) + default: + panic("unreachable") + } + var option1094 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1094 = witTypes.None[string]() + case 1: + value1093 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1094 = witTypes.Some[string](value1093) + default: + panic("unreachable") + } + + option1095 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1090, option1092, option1094}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyU8Type(option1095) + + case 7: + var option1102 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1102 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1097 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1096 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1096 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1096 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1097 = witTypes.Some[golem_core_types.NumericBound](variant1096) + default: + panic("unreachable") + } + var option1099 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1099 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1098 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1098 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1098 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1098 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1099 = witTypes.Some[golem_core_types.NumericBound](variant1098) + default: + panic("unreachable") + } + var option1101 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1101 = witTypes.None[string]() + case 1: + value1100 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1101 = witTypes.Some[string](value1100) + default: + panic("unreachable") + } + + option1102 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1097, option1099, option1101}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyU16Type(option1102) + + case 8: + var option1109 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1109 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1104 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1103 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1103 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1103 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1104 = witTypes.Some[golem_core_types.NumericBound](variant1103) + default: + panic("unreachable") + } + var option1106 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1106 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1105 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1105 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1105 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1105 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1106 = witTypes.Some[golem_core_types.NumericBound](variant1105) + default: + panic("unreachable") + } + var option1108 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1108 = witTypes.None[string]() + case 1: + value1107 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1108 = witTypes.Some[string](value1107) + default: + panic("unreachable") + } + + option1109 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1104, option1106, option1108}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyU32Type(option1109) + + case 9: + var option1116 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1116 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1111 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1110 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1110 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1110 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1111 = witTypes.Some[golem_core_types.NumericBound](variant1110) + default: + panic("unreachable") + } + var option1113 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1113 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1112 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1112 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1112 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1112 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1113 = witTypes.Some[golem_core_types.NumericBound](variant1112) + default: + panic("unreachable") + } + var option1115 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1115 = witTypes.None[string]() + case 1: + value1114 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1115 = witTypes.Some[string](value1114) + default: + panic("unreachable") + } + + option1116 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1111, option1113, option1115}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyU64Type(option1116) + + case 10: + var option1123 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1123 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1118 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1117 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1117 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1117 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1118 = witTypes.Some[golem_core_types.NumericBound](variant1117) + default: + panic("unreachable") + } + var option1120 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1120 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1119 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1119 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1119 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1119 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1120 = witTypes.Some[golem_core_types.NumericBound](variant1119) + default: + panic("unreachable") + } + var option1122 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1122 = witTypes.None[string]() + case 1: + value1121 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1122 = witTypes.Some[string](value1121) + default: + panic("unreachable") + } + + option1123 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1118, option1120, option1122}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyF32Type(option1123) + + case 11: + var option1130 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1130 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1125 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1124 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1124 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1124 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1125 = witTypes.Some[golem_core_types.NumericBound](variant1124) + default: + panic("unreachable") + } + var option1127 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1127 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1126 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1126 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1126 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1126 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1127 = witTypes.Some[golem_core_types.NumericBound](variant1126) + default: + panic("unreachable") + } + var option1129 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1129 = witTypes.None[string]() + case 1: + value1128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1129 = witTypes.Some[string](value1128) + default: + panic("unreachable") + } + + option1130 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1125, option1127, option1129}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyF64Type(option1130) + + case 12: + + variant1224 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1224 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1143 := 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)) + value1131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1133 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1133 = witTypes.None[string]() + case 1: + value1132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1133 = witTypes.Some[string](value1132) + default: + panic("unreachable") + } + result1135 := 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)) + 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) + } + + result1137 := 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)) + value1136 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1137 = append(result1137, value1136) + } + + var option1139 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1139 = witTypes.None[string]() + case 1: + value1138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1139 = witTypes.Some[string](value1138) + default: + panic("unreachable") + } + var option1142 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1142 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1141 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1141 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1141 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1141 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1141 = golem_core_types.MakeRoleOther(value1140) + + default: + panic("unreachable") + } + + option1142 = witTypes.Some[golem_core_types.Role](variant1141) + default: + panic("unreachable") + } + + result1143 = append(result1143, golem_core_types.NamedFieldType{value1131, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1133, result1135, result1137, option1139, option1142}}) + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyRecordType(result1143) + + case 15: + result1157 := 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)) + value1144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1145 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1145 = witTypes.None[int32]() + case 1: + + option1145 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1147 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1147 = witTypes.None[string]() + case 1: + value1146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1147 = witTypes.Some[string](value1146) + default: + panic("unreachable") + } + result1149 := 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)) + 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) + } + + result1151 := 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)) + value1150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1151 = append(result1151, value1150) + } + + var option1153 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1153 = witTypes.None[string]() + case 1: + value1152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1153 = witTypes.Some[string](value1152) + default: + panic("unreachable") + } + var option1156 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1156 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1155 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1155 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1155 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1155 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1154 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1155 = golem_core_types.MakeRoleOther(value1154) + + default: + panic("unreachable") + } + + option1156 = witTypes.Some[golem_core_types.Role](variant1155) + default: + panic("unreachable") + } + + result1157 = append(result1157, golem_core_types.VariantCaseType{value1144, option1145, golem_core_types.MetadataEnvelope{option1147, result1149, result1151, option1153, option1156}}) + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyVariantType(result1157) + + case 16: + 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) + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyEnumType(result1159) + + case 17: + result1161 := 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)) + value1160 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1161 = append(result1161, value1160) + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1161) + + case 18: + result1162 := 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) + + result1162 = append(result1162, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyTupleType(result1162) + + case 19: + + variant1224 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1224 = 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: + + variant1224 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1224 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1163 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1163 = witTypes.None[int32]() + case 1: + + option1163 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1164 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1164 = witTypes.None[int32]() + case 1: + + option1164 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1163, option1164}) + + case 24: + var option1167 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1167 = witTypes.None[[]string]() + case 1: + result1166 := 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)) + value1165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1166 = append(result1166, value1165) + } + + option1167 = witTypes.Some[[]string](result1166) + default: + panic("unreachable") + } + var option1168 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1168 = witTypes.None[uint32]() + case 1: + + option1168 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1169 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1169 = witTypes.None[uint32]() + case 1: + + option1169 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1171 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1171 = witTypes.None[string]() + case 1: + value1170 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1171 = witTypes.Some[string](value1170) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1167, option1168, option1169, option1171}) + + case 25: + var option1174 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1174 = witTypes.None[[]string]() + case 1: + result1173 := 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)) + value1172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1173 = append(result1173, value1172) + } + + option1174 = witTypes.Some[[]string](result1173) + default: + panic("unreachable") + } + var option1175 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1175 = witTypes.None[uint32]() + case 1: + + option1175 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1176 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1176 = witTypes.None[uint32]() + case 1: + + option1176 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1174, option1175, option1176}) + + case 26: + var option1179 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1179 = witTypes.None[[]string]() + case 1: + result1178 := 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)) + 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") + } + var option1182 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1182 = witTypes.None[[]string]() + case 1: + result1181 := 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)) + 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") + } + + variant1224 = 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)))), option1179, option1182}) + + case 27: + var option1185 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1185 = witTypes.None[[]string]() + case 1: + result1184 := 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)) + 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") + } + var option1188 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1188 = witTypes.None[[]string]() + case 1: + result1187 := 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)) + value1186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1187 = append(result1187, value1186) + } + + option1188 = witTypes.Some[[]string](result1187) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1185, option1188}) + + case 28: + + variant1224 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1224 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1191 := 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)) + value1190 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1191 = append(result1191, value1190) + } + + var option1193 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1193 = 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))), value1192}) + default: + panic("unreachable") + } + var option1195 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1195 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1195 = 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))), value1194}) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1189, result1191, option1193, option1195}) + + case 31: + result1217 := 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)) + value1196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1205 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1205 = golem_core_types.MakeDiscriminatorRulePrefix(value1197) + + case 1: + value1198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1205 = golem_core_types.MakeDiscriminatorRuleSuffix(value1198) + + case 2: + value1199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1205 = golem_core_types.MakeDiscriminatorRuleContains(value1199) + + case 3: + value1200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1205 = golem_core_types.MakeDiscriminatorRuleRegex(value1200) + + case 4: + value1201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1203 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1203 = witTypes.None[string]() + case 1: + value1202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1203 = witTypes.Some[string](value1202) + default: + panic("unreachable") + } + + variant1205 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1201, option1203}) + + case 5: + value1204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1205 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1204) + + default: + panic("unreachable") + } + var option1207 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1207 = witTypes.None[string]() + case 1: + value1206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1207 = witTypes.Some[string](value1206) + default: + panic("unreachable") + } + result1209 := 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)) + 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) + } + + result1211 := 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)) + value1210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1211 = append(result1211, value1210) + } + + var option1213 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1213 = witTypes.None[string]() + case 1: + value1212 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1213 = witTypes.Some[string](value1212) + default: + panic("unreachable") + } + var option1216 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1216 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1215 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1215 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1215 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1215 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1214 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1215 = golem_core_types.MakeRoleOther(value1214) + + default: + panic("unreachable") + } + + option1216 = witTypes.Some[golem_core_types.Role](variant1215) + default: + panic("unreachable") + } + + result1217 = append(result1217, golem_core_types.UnionBranch{value1196, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1205, golem_core_types.MetadataEnvelope{option1207, result1209, result1211, option1213, option1216}}) + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1217}) + + case 32: + var option1219 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1219 = witTypes.None[string]() + case 1: + value1218 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1219 = witTypes.Some[string](value1218) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1219}) + + case 33: + var option1221 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1221 = witTypes.None[string]() + case 1: + value1220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1221 = witTypes.Some[string](value1220) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1221}) + + case 34: + + variant1224 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1222 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1222 = witTypes.None[int32]() + case 1: + + option1222 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyFutureType(option1222) + + case 36: + var option1223 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1223 = witTypes.None[int32]() + case 1: + + option1223 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1224 = golem_core_types.MakeSchemaTypeBodyStreamType(option1223) + + default: + panic("unreachable") + } + var option1226 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1226 = witTypes.None[string]() + case 1: + value1225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1226 = witTypes.Some[string](value1225) + default: + panic("unreachable") + } + result1228 := 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)) + 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) + } + + result1230 := 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)) + value1229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1230 = append(result1230, value1229) + } + + var option1232 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1232 = witTypes.None[string]() + case 1: + value1231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1232 = witTypes.Some[string](value1231) + default: + panic("unreachable") + } + var option1235 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1235 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1234 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1234 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1234 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1234 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1234 = golem_core_types.MakeRoleOther(value1233) + + default: + panic("unreachable") + } + + option1235 = witTypes.Some[golem_core_types.Role](variant1234) + default: + panic("unreachable") + } + + result1236 = append(result1236, golem_core_types.SchemaTypeNode{variant1224, golem_core_types.MetadataEnvelope{option1226, result1228, result1230, option1232, option1235}}) + } + + result1240 := 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)) + value1237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1239 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1239 = witTypes.None[string]() + case 1: + value1238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1239 = witTypes.Some[string](value1238) + default: + panic("unreachable") + } + + result1240 = append(result1240, golem_core_types.SchemaTypeDef{value1237, option1239, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1264 := 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 variant1263 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1263 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1263 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1263 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1263 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1263 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1263 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1263 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1263 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1263 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1263 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1263 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1263 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1241 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1263 = golem_core_types.MakeSchemaValueNodeStringValue(value1241) + + case 13: + 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))) + } + + variant1263 = golem_core_types.MakeSchemaValueNodeRecordValue(result1242) + + case 14: + var option1243 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1243 = witTypes.None[int32]() + case 1: + + option1243 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1263 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1243}) + + case 15: + + variant1263 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1244 := 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) + + result1244 = append(result1244, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1263 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1244) + + case 17: + 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))) + } + + variant1263 = golem_core_types.MakeSchemaValueNodeTupleValue(result1245) + + case 18: + result1246 := 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) + + result1246 = append(result1246, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1263 = golem_core_types.MakeSchemaValueNodeListValue(result1246) + + case 19: + result1247 := 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) + + result1247 = append(result1247, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1263 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1247) + + case 20: + result1248 := 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) + + result1248 = append(result1248, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1263 = golem_core_types.MakeSchemaValueNodeMapValue(result1248) + + case 21: + var option1249 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1249 = witTypes.None[int32]() + case 1: + + option1249 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1263 = golem_core_types.MakeSchemaValueNodeOptionValue(option1249) + + case 22: + var variant1252 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1250 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1250 = witTypes.None[int32]() + case 1: + + option1250 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1252 = golem_core_types.MakeResultValuePayloadOkValue(option1250) + + case 1: + var option1251 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1251 = witTypes.None[int32]() + case 1: + + option1251 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1252 = golem_core_types.MakeResultValuePayloadErrValue(option1251) + + default: + panic("unreachable") + } + + variant1263 = golem_core_types.MakeSchemaValueNodeResultValue(variant1252) + + case 23: + value1253 := unsafe.String((*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") + } + + variant1263 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1253, option1255}) + + case 24: + value1256 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1258 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1258 = witTypes.None[string]() + case 1: + value1257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1258 = witTypes.Some[string](value1257) + default: + panic("unreachable") + } + + variant1263 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1256, option1258}) + + case 25: + value1259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1263 = golem_core_types.MakeSchemaValueNodePathValue(value1259) + + case 26: + value1260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1263 = golem_core_types.MakeSchemaValueNodeUrlValue(value1260) + + case 27: + + variant1263 = 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: + + variant1263 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1261 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1263 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1261}) + + case 30: + value1262 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1263 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1262, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1263 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1263 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1263 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1264 = append(result1264, variant1263) + } + + value1265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))) + result1267 := 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)) + value1266 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1267 = append(result1267, value1266) + } + + result1279 := 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)) + result1278 := 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 variant1277 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1268 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1270 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1270 = witTypes.None[string]() + case 1: + value1269 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1270 = witTypes.Some[string](value1269) + default: + panic("unreachable") + } + var option1271 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1271 = witTypes.None[uint64]() + case 1: + + option1271 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1275 := 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)) + value1272 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1274 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1273 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1274 = golem_api_context.MakeAttributeValueString(value1273) + + default: + panic("unreachable") + } + + result1275 = append(result1275, golem_api_context.Attribute{value1272, variant1274}) + } + + variant1277 = MakeSpanDataLocalSpan(LocalSpanData{value1268, 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))))}, option1270, option1271, result1275, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1276 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1277 = MakeSpanDataExternalSpan(ExternalSpanData{value1276}) + + default: + panic("unreachable") + } + + result1278 = append(result1278, variant1277) + } + + result1279 = append(result1279, result1278) + } + + variant1504 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1060, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1236, result1240, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result1264, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value1265, result1267, result1279}) + + case 1: + value1280 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value1281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + result1457 := 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 variant1445 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1445 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1445 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1288 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1288 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1283 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1282 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1282 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1282 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1283 = witTypes.Some[golem_core_types.NumericBound](variant1282) + default: + panic("unreachable") + } + var option1285 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1285 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1284 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1284 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1284 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1284 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1285 = witTypes.Some[golem_core_types.NumericBound](variant1284) + default: + panic("unreachable") + } + var option1287 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1287 = witTypes.None[string]() + case 1: + value1286 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1287 = witTypes.Some[string](value1286) + default: + panic("unreachable") + } + + option1288 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1283, option1285, option1287}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyS8Type(option1288) + + case 3: + var option1295 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1295 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1290 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1289 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1289 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1289 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1290 = witTypes.Some[golem_core_types.NumericBound](variant1289) + default: + panic("unreachable") + } + var option1292 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1292 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1291 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1291 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1291 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1291 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1292 = witTypes.Some[golem_core_types.NumericBound](variant1291) + default: + panic("unreachable") + } + var option1294 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1294 = witTypes.None[string]() + case 1: + value1293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1294 = witTypes.Some[string](value1293) + default: + panic("unreachable") + } + + option1295 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1290, option1292, option1294}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyS16Type(option1295) + + case 4: + var option1302 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1302 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1297 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1296 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1296 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1296 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1297 = witTypes.Some[golem_core_types.NumericBound](variant1296) + default: + panic("unreachable") + } + var option1299 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1299 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1298 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1298 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1298 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1298 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1299 = witTypes.Some[golem_core_types.NumericBound](variant1298) + default: + panic("unreachable") + } + var option1301 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1301 = witTypes.None[string]() + case 1: + value1300 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1301 = witTypes.Some[string](value1300) + default: + panic("unreachable") + } + + option1302 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1297, option1299, option1301}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyS32Type(option1302) + + case 5: + var option1309 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1309 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1304 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1303 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1303 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1303 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1304 = witTypes.Some[golem_core_types.NumericBound](variant1303) + default: + panic("unreachable") + } + var option1306 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1306 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1305 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1305 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1305 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1305 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1306 = witTypes.Some[golem_core_types.NumericBound](variant1305) + default: + panic("unreachable") + } + var option1308 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1308 = witTypes.None[string]() + case 1: + value1307 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1308 = witTypes.Some[string](value1307) + default: + panic("unreachable") + } + + option1309 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1304, option1306, option1308}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyS64Type(option1309) + + case 6: + var option1316 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1316 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1311 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1310 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1310 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1310 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1311 = witTypes.Some[golem_core_types.NumericBound](variant1310) + default: + panic("unreachable") + } + var option1313 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1313 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1312 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1312 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1312 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1312 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1313 = witTypes.Some[golem_core_types.NumericBound](variant1312) + default: + panic("unreachable") + } + var option1315 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1315 = witTypes.None[string]() + case 1: + value1314 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1315 = witTypes.Some[string](value1314) + default: + panic("unreachable") + } + + option1316 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1311, option1313, option1315}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyU8Type(option1316) + + case 7: + var option1323 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1323 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1318 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1317 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1317 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1317 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1318 = witTypes.Some[golem_core_types.NumericBound](variant1317) + default: + panic("unreachable") + } + var option1320 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1320 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1319 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1319 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1319 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1319 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1320 = witTypes.Some[golem_core_types.NumericBound](variant1319) + default: + panic("unreachable") + } + var option1322 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1322 = witTypes.None[string]() + case 1: + value1321 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1322 = witTypes.Some[string](value1321) + default: + panic("unreachable") + } + + option1323 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1318, option1320, option1322}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyU16Type(option1323) + + case 8: + var option1330 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1330 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1325 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1324 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1324 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1324 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1325 = witTypes.Some[golem_core_types.NumericBound](variant1324) + default: + panic("unreachable") + } + var option1327 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1327 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1326 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1326 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1326 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1326 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1327 = witTypes.Some[golem_core_types.NumericBound](variant1326) + default: + panic("unreachable") + } + var option1329 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1329 = witTypes.None[string]() + case 1: + value1328 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1329 = witTypes.Some[string](value1328) + default: + panic("unreachable") + } + + option1330 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1325, option1327, option1329}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyU32Type(option1330) + + case 9: + var option1337 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1337 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1332 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1331 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1331 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1331 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1332 = witTypes.Some[golem_core_types.NumericBound](variant1331) + default: + panic("unreachable") + } + var option1334 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1334 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1333 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1333 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1333 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1333 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1334 = witTypes.Some[golem_core_types.NumericBound](variant1333) + default: + panic("unreachable") + } + var option1336 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1336 = witTypes.None[string]() + case 1: + value1335 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1336 = witTypes.Some[string](value1335) + default: + panic("unreachable") + } + + option1337 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1332, option1334, option1336}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyU64Type(option1337) + + case 10: + var option1344 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1344 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1339 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1338 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1338 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1338 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1339 = witTypes.Some[golem_core_types.NumericBound](variant1338) + default: + panic("unreachable") + } + var option1341 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1341 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1340 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1340 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1340 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1340 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1341 = witTypes.Some[golem_core_types.NumericBound](variant1340) + default: + panic("unreachable") + } + var option1343 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1343 = witTypes.None[string]() + case 1: + value1342 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1343 = witTypes.Some[string](value1342) + default: + panic("unreachable") + } + + option1344 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1339, option1341, option1343}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyF32Type(option1344) + + case 11: + var option1351 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1351 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1346 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1345 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1345 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1345 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1346 = witTypes.Some[golem_core_types.NumericBound](variant1345) + default: + panic("unreachable") + } + var option1348 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1348 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1347 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1347 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1347 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1347 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1348 = witTypes.Some[golem_core_types.NumericBound](variant1347) + default: + panic("unreachable") + } + var option1350 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1350 = witTypes.None[string]() + case 1: + value1349 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1350 = witTypes.Some[string](value1349) + default: + panic("unreachable") + } + + option1351 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1346, option1348, option1350}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyF64Type(option1351) + + case 12: + + variant1445 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1445 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1364 := 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)) + value1352 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1354 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1354 = witTypes.None[string]() + case 1: + value1353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1354 = witTypes.Some[string](value1353) + default: + panic("unreachable") + } + result1356 := 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)) + 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) + } + + result1358 := 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)) + value1357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1358 = append(result1358, value1357) + } + + var option1360 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1360 = witTypes.None[string]() + case 1: + value1359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1360 = witTypes.Some[string](value1359) + default: + panic("unreachable") + } + var option1363 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1363 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1362 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1362 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1362 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1362 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1362 = golem_core_types.MakeRoleOther(value1361) + + default: + panic("unreachable") + } + + option1363 = witTypes.Some[golem_core_types.Role](variant1362) + default: + panic("unreachable") + } + + result1364 = append(result1364, golem_core_types.NamedFieldType{value1352, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1354, result1356, result1358, option1360, option1363}}) + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyRecordType(result1364) + + case 15: + result1378 := 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)) + value1365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1366 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1366 = witTypes.None[int32]() + case 1: + + option1366 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1368 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1368 = witTypes.None[string]() + case 1: + value1367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1368 = witTypes.Some[string](value1367) + default: + panic("unreachable") + } + result1370 := 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)) + 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) + } + + result1372 := 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)) + value1371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1372 = append(result1372, value1371) + } + + var option1374 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1374 = witTypes.None[string]() + case 1: + value1373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1374 = witTypes.Some[string](value1373) + default: + panic("unreachable") + } + var option1377 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1377 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1376 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1376 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1376 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1376 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1376 = golem_core_types.MakeRoleOther(value1375) + + default: + panic("unreachable") + } + + option1377 = witTypes.Some[golem_core_types.Role](variant1376) + default: + panic("unreachable") + } + + result1378 = append(result1378, golem_core_types.VariantCaseType{value1365, option1366, golem_core_types.MetadataEnvelope{option1368, result1370, result1372, option1374, option1377}}) + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyVariantType(result1378) + + case 16: + 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) + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyEnumType(result1380) + + case 17: + result1382 := 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)) + value1381 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1382 = append(result1382, value1381) + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1382) + + case 18: + result1383 := 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) + + result1383 = append(result1383, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyTupleType(result1383) + + case 19: + + variant1445 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1445 = 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: + + variant1445 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1445 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1384 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1384 = witTypes.None[int32]() + case 1: + + option1384 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1385 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1385 = witTypes.None[int32]() + case 1: + + option1385 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1384, option1385}) + + case 24: + var option1388 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1388 = witTypes.None[[]string]() + case 1: + result1387 := 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)) + value1386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1387 = append(result1387, value1386) + } + + option1388 = witTypes.Some[[]string](result1387) + default: + panic("unreachable") + } + var option1389 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1389 = witTypes.None[uint32]() + case 1: + + option1389 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1390 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1390 = witTypes.None[uint32]() + case 1: + + option1390 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1392 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1392 = witTypes.None[string]() + case 1: + value1391 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1392 = witTypes.Some[string](value1391) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1388, option1389, option1390, option1392}) + + case 25: + var option1395 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1395 = witTypes.None[[]string]() + case 1: + result1394 := 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)) + value1393 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1394 = append(result1394, value1393) + } + + option1395 = witTypes.Some[[]string](result1394) + default: + panic("unreachable") + } + var option1396 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1396 = witTypes.None[uint32]() + case 1: + + option1396 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1397 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1397 = witTypes.None[uint32]() + case 1: + + option1397 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1395, option1396, option1397}) + + case 26: + var option1400 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1400 = witTypes.None[[]string]() + case 1: + result1399 := 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)) + value1398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1399 = append(result1399, value1398) + } + + option1400 = witTypes.Some[[]string](result1399) + default: + panic("unreachable") + } + var option1403 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1403 = witTypes.None[[]string]() + case 1: + result1402 := 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)) + value1401 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1402 = append(result1402, value1401) + } + + option1403 = witTypes.Some[[]string](result1402) + default: + panic("unreachable") + } + + variant1445 = 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)))), option1400, option1403}) + + case 27: + var option1406 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1406 = witTypes.None[[]string]() + case 1: + result1405 := 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)) + value1404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1405 = append(result1405, value1404) + } + + option1406 = witTypes.Some[[]string](result1405) + default: + panic("unreachable") + } + var option1409 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1409 = witTypes.None[[]string]() + case 1: + result1408 := 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)) + value1407 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1408 = append(result1408, value1407) + } + + option1409 = witTypes.Some[[]string](result1408) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1406, option1409}) + + case 28: + + variant1445 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1445 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1410 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1412 := 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)) + value1411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1412 = append(result1412, value1411) + } + + var option1414 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1414 = 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))), value1413}) + default: + panic("unreachable") + } + var option1416 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1416 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1415 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1416 = 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))), value1415}) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1410, result1412, option1414, option1416}) + + case 31: + result1438 := 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)) + value1417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1426 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1426 = golem_core_types.MakeDiscriminatorRulePrefix(value1418) + + case 1: + value1419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1426 = golem_core_types.MakeDiscriminatorRuleSuffix(value1419) + + case 2: + value1420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1426 = golem_core_types.MakeDiscriminatorRuleContains(value1420) + + case 3: + value1421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1426 = golem_core_types.MakeDiscriminatorRuleRegex(value1421) + + case 4: + value1422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1424 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1424 = witTypes.None[string]() + case 1: + value1423 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1424 = witTypes.Some[string](value1423) + default: + panic("unreachable") + } + + variant1426 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1422, option1424}) + + case 5: + value1425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1426 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1425) + + default: + panic("unreachable") + } + var option1428 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1428 = witTypes.None[string]() + case 1: + value1427 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1428 = witTypes.Some[string](value1427) + default: + panic("unreachable") + } + result1430 := 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)) + 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) + } + + result1432 := 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)) + value1431 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1432 = append(result1432, value1431) + } + + var option1434 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1434 = witTypes.None[string]() + case 1: + value1433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1434 = witTypes.Some[string](value1433) + default: + panic("unreachable") + } + var option1437 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1437 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1436 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1436 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1436 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1436 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1435 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1436 = golem_core_types.MakeRoleOther(value1435) + + default: + panic("unreachable") + } + + option1437 = witTypes.Some[golem_core_types.Role](variant1436) + default: + panic("unreachable") + } + + result1438 = append(result1438, golem_core_types.UnionBranch{value1417, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1426, golem_core_types.MetadataEnvelope{option1428, result1430, result1432, option1434, option1437}}) + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1438}) + + case 32: + var option1440 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1440 = witTypes.None[string]() + case 1: + value1439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1440 = witTypes.Some[string](value1439) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1440}) + + case 33: + var option1442 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1442 = witTypes.None[string]() + case 1: + value1441 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1442 = witTypes.Some[string](value1441) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1442}) + + case 34: + + variant1445 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyFutureType(option1443) + + case 36: + var option1444 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1444 = witTypes.None[int32]() + case 1: + + option1444 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1445 = golem_core_types.MakeSchemaTypeBodyStreamType(option1444) + + default: + panic("unreachable") + } + var option1447 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1447 = witTypes.None[string]() + case 1: + value1446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1447 = witTypes.Some[string](value1446) + default: + panic("unreachable") + } + result1449 := 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)) + 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) + } + + result1451 := 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)) + value1450 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1451 = append(result1451, value1450) + } + + var option1453 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1453 = witTypes.None[string]() + case 1: + value1452 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1453 = witTypes.Some[string](value1452) + default: + panic("unreachable") + } + var option1456 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1456 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1455 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1455 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1455 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1455 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1454 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1455 = golem_core_types.MakeRoleOther(value1454) + + default: + panic("unreachable") + } + + option1456 = witTypes.Some[golem_core_types.Role](variant1455) + default: + panic("unreachable") + } + + result1457 = append(result1457, golem_core_types.SchemaTypeNode{variant1445, golem_core_types.MetadataEnvelope{option1447, result1449, result1451, option1453, option1456}}) + } + + result1461 := 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)) + value1458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1460 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1460 = witTypes.None[string]() + case 1: + value1459 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1460 = witTypes.Some[string](value1459) + default: + panic("unreachable") + } + + result1461 = append(result1461, golem_core_types.SchemaTypeDef{value1458, option1460, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1485 := 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 variant1484 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1484 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1484 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1484 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1484 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1484 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1484 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1484 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1484 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1484 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1484 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1484 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1484 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1462 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1484 = golem_core_types.MakeSchemaValueNodeStringValue(value1462) + + case 13: + result1463 := 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) + + result1463 = append(result1463, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1484 = golem_core_types.MakeSchemaValueNodeRecordValue(result1463) + + case 14: + var option1464 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1464 = witTypes.None[int32]() + case 1: + + option1464 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1484 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1464}) + + case 15: + + variant1484 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1465 := 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) + + result1465 = append(result1465, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1484 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1465) + + case 17: + 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))) + } + + variant1484 = golem_core_types.MakeSchemaValueNodeTupleValue(result1466) + + case 18: + 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))) + } + + variant1484 = golem_core_types.MakeSchemaValueNodeListValue(result1467) + + case 19: + result1468 := 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) + + result1468 = append(result1468, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1484 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1468) + + case 20: + result1469 := 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) + + result1469 = append(result1469, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1484 = golem_core_types.MakeSchemaValueNodeMapValue(result1469) + + case 21: + var option1470 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1470 = witTypes.None[int32]() + case 1: + + option1470 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1484 = golem_core_types.MakeSchemaValueNodeOptionValue(option1470) + + case 22: + var variant1473 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant1473 = golem_core_types.MakeResultValuePayloadOkValue(option1471) + + case 1: + var option1472 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1472 = witTypes.None[int32]() + case 1: + + option1472 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1473 = golem_core_types.MakeResultValuePayloadErrValue(option1472) + + default: + panic("unreachable") + } + + variant1484 = golem_core_types.MakeSchemaValueNodeResultValue(variant1473) + + case 23: + value1474 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1476 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1476 = witTypes.None[string]() + case 1: + value1475 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1476 = witTypes.Some[string](value1475) + default: + panic("unreachable") + } + + variant1484 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1474, option1476}) + + case 24: + value1477 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1479 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1479 = witTypes.None[string]() + case 1: + value1478 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1479 = witTypes.Some[string](value1478) + default: + panic("unreachable") + } + + variant1484 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1477, option1479}) + + case 25: + value1480 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1484 = golem_core_types.MakeSchemaValueNodePathValue(value1480) + + case 26: + value1481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1484 = golem_core_types.MakeSchemaValueNodeUrlValue(value1481) + + case 27: + + variant1484 = 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: + + variant1484 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1482 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1484 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1482}) + + case 30: + value1483 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1484 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1483, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1484 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1484 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1484 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1485 = append(result1485, variant1484) + } + + value1486 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))) + result1488 := 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)) + value1487 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1488 = append(result1488, value1487) + } + + result1500 := 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)) + result1499 := 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 variant1498 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1489 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1491 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1491 = witTypes.None[string]() + case 1: + value1490 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1491 = witTypes.Some[string](value1490) + default: + panic("unreachable") + } + var option1492 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1492 = witTypes.None[uint64]() + case 1: + + option1492 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1496 := 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)) + value1493 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1495 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1494 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1495 = golem_api_context.MakeAttributeValueString(value1494) + + default: + panic("unreachable") + } + + result1496 = append(result1496, golem_api_context.Attribute{value1493, variant1495}) + } + + variant1498 = MakeSpanDataLocalSpan(LocalSpanData{value1489, 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))))}, option1491, option1492, result1496, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1497 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1498 = MakeSpanDataExternalSpan(ExternalSpanData{value1497}) + + default: + panic("unreachable") + } + + result1499 = append(result1499, variant1498) + } + + result1500 = append(result1500, result1499) + } + + variant1504 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1280, value1281, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1457, result1461, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result1485, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value1486, result1488, result1500}) + + case 2: + + variant1504 = MakeAgentInvocationSaveSnapshot() + + case 3: + value1501 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value1502 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + variant1504 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value1501, value1502}}) + + case 4: + value1503 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant1504 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value1503}) + + case 5: + + variant1504 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}) + + default: + panic("unreachable") + } + + variant2694 = 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)))}, variant1504}) + + case 5: + var variant1919 AgentInvocationResult + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + result1680 := 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 variant1668 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1668 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1668 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1511 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1511 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1506 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1505 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1505 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1505 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1506 = witTypes.Some[golem_core_types.NumericBound](variant1505) + default: + panic("unreachable") + } + var option1508 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1508 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1507 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1507 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1507 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1507 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1508 = witTypes.Some[golem_core_types.NumericBound](variant1507) + default: + panic("unreachable") + } + var option1510 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1510 = witTypes.None[string]() + case 1: + value1509 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1510 = witTypes.Some[string](value1509) + default: + panic("unreachable") + } + + option1511 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1506, option1508, option1510}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyS8Type(option1511) + + case 3: + var option1518 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1518 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1513 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1512 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1512 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1512 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1513 = witTypes.Some[golem_core_types.NumericBound](variant1512) + default: + panic("unreachable") + } + var option1515 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1515 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1514 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1514 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1514 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1514 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1515 = witTypes.Some[golem_core_types.NumericBound](variant1514) + default: + panic("unreachable") + } + var option1517 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1517 = witTypes.None[string]() + case 1: + value1516 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1517 = witTypes.Some[string](value1516) + default: + panic("unreachable") + } + + option1518 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1513, option1515, option1517}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyS16Type(option1518) + + case 4: + var option1525 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1525 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1520 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1519 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1519 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1519 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1520 = witTypes.Some[golem_core_types.NumericBound](variant1519) + default: + panic("unreachable") + } + var option1522 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1522 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1521 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1521 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1521 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1521 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1522 = witTypes.Some[golem_core_types.NumericBound](variant1521) + default: + panic("unreachable") + } + var option1524 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1524 = witTypes.None[string]() + case 1: + value1523 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1524 = witTypes.Some[string](value1523) + default: + panic("unreachable") + } + + option1525 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1520, option1522, option1524}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyS32Type(option1525) + + case 5: + var option1532 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1532 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1527 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1526 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1526 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1526 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1527 = witTypes.Some[golem_core_types.NumericBound](variant1526) + default: + panic("unreachable") + } + var option1529 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1529 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1528 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1528 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1528 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1528 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1529 = witTypes.Some[golem_core_types.NumericBound](variant1528) + default: + panic("unreachable") + } + var option1531 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1531 = witTypes.None[string]() + case 1: + value1530 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1531 = witTypes.Some[string](value1530) + default: + panic("unreachable") + } + + option1532 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1527, option1529, option1531}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyS64Type(option1532) + + case 6: + var option1539 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1539 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1534 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1533 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1533 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1533 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1534 = witTypes.Some[golem_core_types.NumericBound](variant1533) + default: + panic("unreachable") + } + var option1536 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1536 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1535 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1535 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1535 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1535 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1536 = witTypes.Some[golem_core_types.NumericBound](variant1535) + default: + panic("unreachable") + } + var option1538 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1538 = witTypes.None[string]() + case 1: + value1537 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1538 = witTypes.Some[string](value1537) + default: + panic("unreachable") + } + + option1539 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1534, option1536, option1538}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyU8Type(option1539) + + case 7: + var option1546 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1546 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1541 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1540 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1540 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1540 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1541 = witTypes.Some[golem_core_types.NumericBound](variant1540) + default: + panic("unreachable") + } + var option1543 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1543 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1542 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1542 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1542 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1542 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1543 = witTypes.Some[golem_core_types.NumericBound](variant1542) + default: + panic("unreachable") + } + var option1545 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1545 = witTypes.None[string]() + case 1: + value1544 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1545 = witTypes.Some[string](value1544) + default: + panic("unreachable") + } + + option1546 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1541, option1543, option1545}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyU16Type(option1546) + + case 8: + var option1553 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1553 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1548 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1547 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1547 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1547 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1548 = witTypes.Some[golem_core_types.NumericBound](variant1547) + default: + panic("unreachable") + } + var option1550 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1550 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1549 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1549 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1549 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1549 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1550 = witTypes.Some[golem_core_types.NumericBound](variant1549) + default: + panic("unreachable") + } + var option1552 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1552 = witTypes.None[string]() + case 1: + value1551 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1552 = witTypes.Some[string](value1551) + default: + panic("unreachable") + } + + option1553 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1548, option1550, option1552}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyU32Type(option1553) + + case 9: + var option1560 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1560 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1555 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1554 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1554 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1554 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1555 = witTypes.Some[golem_core_types.NumericBound](variant1554) + default: + panic("unreachable") + } + var option1557 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1557 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1556 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1556 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1556 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1556 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1557 = witTypes.Some[golem_core_types.NumericBound](variant1556) + default: + panic("unreachable") + } + var option1559 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1559 = witTypes.None[string]() + case 1: + value1558 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1559 = witTypes.Some[string](value1558) + default: + panic("unreachable") + } + + option1560 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1555, option1557, option1559}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyU64Type(option1560) + + case 10: + var option1567 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1567 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1562 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1561 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1561 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1561 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1562 = witTypes.Some[golem_core_types.NumericBound](variant1561) + default: + panic("unreachable") + } + var option1564 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1564 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1563 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1563 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1563 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1563 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1564 = witTypes.Some[golem_core_types.NumericBound](variant1563) + default: + panic("unreachable") + } + var option1566 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1566 = witTypes.None[string]() + case 1: + value1565 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1566 = witTypes.Some[string](value1565) + default: + panic("unreachable") + } + + option1567 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1562, option1564, option1566}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyF32Type(option1567) + + case 11: + var option1574 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1574 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1569 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1568 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1568 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1568 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1569 = witTypes.Some[golem_core_types.NumericBound](variant1568) + default: + panic("unreachable") + } + var option1571 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1571 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1570 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1570 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1570 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1570 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1571 = witTypes.Some[golem_core_types.NumericBound](variant1570) + default: + panic("unreachable") + } + var option1573 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1573 = witTypes.None[string]() + case 1: + value1572 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1573 = witTypes.Some[string](value1572) + default: + panic("unreachable") + } + + option1574 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1569, option1571, option1573}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyF64Type(option1574) + + case 12: + + variant1668 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1668 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1587 := 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)) + value1575 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1577 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1577 = witTypes.None[string]() + case 1: + value1576 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1577 = witTypes.Some[string](value1576) + default: + panic("unreachable") + } + result1579 := 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)) + 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) + } + + result1581 := 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)) + value1580 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1581 = append(result1581, value1580) + } + + var option1583 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1583 = witTypes.None[string]() + case 1: + value1582 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1583 = witTypes.Some[string](value1582) + default: + panic("unreachable") + } + var option1586 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1586 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1585 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1585 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1585 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1585 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1584 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1585 = golem_core_types.MakeRoleOther(value1584) + + default: + panic("unreachable") + } + + option1586 = witTypes.Some[golem_core_types.Role](variant1585) + default: + panic("unreachable") + } + + result1587 = append(result1587, golem_core_types.NamedFieldType{value1575, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1577, result1579, result1581, option1583, option1586}}) + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyRecordType(result1587) + + case 15: + result1601 := 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)) + value1588 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1589 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1589 = witTypes.None[int32]() + case 1: + + option1589 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1591 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1591 = witTypes.None[string]() + case 1: + value1590 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1591 = witTypes.Some[string](value1590) + default: + panic("unreachable") + } + result1593 := 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)) + 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) + } + + result1595 := 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)) + value1594 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1595 = append(result1595, value1594) + } + + var option1597 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1597 = witTypes.None[string]() + case 1: + value1596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1597 = witTypes.Some[string](value1596) + default: + panic("unreachable") + } + var option1600 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1600 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1599 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1599 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1599 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1599 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1599 = golem_core_types.MakeRoleOther(value1598) + + default: + panic("unreachable") + } + + option1600 = witTypes.Some[golem_core_types.Role](variant1599) + default: + panic("unreachable") + } + + result1601 = append(result1601, golem_core_types.VariantCaseType{value1588, option1589, golem_core_types.MetadataEnvelope{option1591, result1593, result1595, option1597, option1600}}) + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyVariantType(result1601) + + case 16: + 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) + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyEnumType(result1603) + + case 17: + result1605 := 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)) + 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) + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1605) + + case 18: + result1606 := 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) + + result1606 = append(result1606, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyTupleType(result1606) + + case 19: + + variant1668 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1668 = 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: + + variant1668 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1668 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1607 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1607 = witTypes.None[int32]() + case 1: + + option1607 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1608 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1608 = witTypes.None[int32]() + case 1: + + option1608 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1607, option1608}) + + case 24: + var option1611 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1611 = witTypes.None[[]string]() + case 1: + result1610 := 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)) + value1609 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1610 = append(result1610, value1609) + } + + option1611 = witTypes.Some[[]string](result1610) + default: + panic("unreachable") + } + var option1612 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1612 = witTypes.None[uint32]() + case 1: + + option1612 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1613 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1613 = witTypes.None[uint32]() + case 1: + + option1613 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1615 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1615 = witTypes.None[string]() + case 1: + value1614 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1615 = witTypes.Some[string](value1614) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1611, option1612, option1613, option1615}) + + case 25: + var option1618 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1618 = witTypes.None[[]string]() + case 1: + result1617 := 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)) + value1616 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1617 = append(result1617, value1616) + } + + option1618 = witTypes.Some[[]string](result1617) + default: + panic("unreachable") + } + var option1619 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1619 = witTypes.None[uint32]() + case 1: + + option1619 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1620 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1620 = witTypes.None[uint32]() + case 1: + + option1620 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1618, option1619, option1620}) + + case 26: + var option1623 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1623 = witTypes.None[[]string]() + case 1: + result1622 := 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)) + value1621 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1622 = append(result1622, value1621) + } + + option1623 = witTypes.Some[[]string](result1622) + default: + panic("unreachable") + } + var option1626 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1626 = witTypes.None[[]string]() + case 1: + result1625 := 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)) + value1624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1625 = append(result1625, value1624) + } + + option1626 = witTypes.Some[[]string](result1625) + default: + panic("unreachable") + } + + variant1668 = 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)))), option1623, option1626}) + + case 27: + var option1629 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1629 = witTypes.None[[]string]() + case 1: + result1628 := 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)) + value1627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1628 = append(result1628, value1627) + } + + option1629 = witTypes.Some[[]string](result1628) + default: + panic("unreachable") + } + var option1632 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1632 = witTypes.None[[]string]() + case 1: + result1631 := 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)) + value1630 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1631 = append(result1631, value1630) + } + + option1632 = witTypes.Some[[]string](result1631) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1629, option1632}) + + case 28: + + variant1668 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1668 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1633 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1635 := 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)) + 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[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1637 = 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))), value1636}) + default: + panic("unreachable") + } + var option1639 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1639 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1639 = 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))), value1638}) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1633, result1635, option1637, option1639}) + + case 31: + result1661 := 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)) + value1640 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1649 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1641 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1649 = golem_core_types.MakeDiscriminatorRulePrefix(value1641) + + case 1: + value1642 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1649 = golem_core_types.MakeDiscriminatorRuleSuffix(value1642) + + case 2: + value1643 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1649 = golem_core_types.MakeDiscriminatorRuleContains(value1643) + + case 3: + value1644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1649 = golem_core_types.MakeDiscriminatorRuleRegex(value1644) + + case 4: + value1645 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1647 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1647 = witTypes.None[string]() + case 1: + value1646 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1647 = witTypes.Some[string](value1646) + default: + panic("unreachable") + } + + variant1649 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1645, option1647}) + + case 5: + value1648 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1649 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1648) + + default: + panic("unreachable") + } + var option1651 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1651 = witTypes.None[string]() + case 1: + value1650 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1651 = witTypes.Some[string](value1650) + default: + panic("unreachable") + } + result1653 := 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)) + 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) + } + + result1655 := 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)) + value1654 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1655 = append(result1655, value1654) + } + + var option1657 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1657 = witTypes.None[string]() + case 1: + value1656 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1657 = witTypes.Some[string](value1656) + default: + panic("unreachable") + } + var option1660 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1660 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1659 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1659 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1659 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1659 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1658 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1659 = golem_core_types.MakeRoleOther(value1658) + + default: + panic("unreachable") + } + + option1660 = witTypes.Some[golem_core_types.Role](variant1659) + default: + panic("unreachable") + } + + result1661 = append(result1661, golem_core_types.UnionBranch{value1640, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1649, golem_core_types.MetadataEnvelope{option1651, result1653, result1655, option1657, option1660}}) + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1661}) + + case 32: + var option1663 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1663 = witTypes.None[string]() + case 1: + value1662 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1663 = witTypes.Some[string](value1662) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1663}) + + case 33: + var option1665 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1665 = witTypes.None[string]() + case 1: + value1664 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1665 = witTypes.Some[string](value1664) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1665}) + + case 34: + + variant1668 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1666 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1666 = witTypes.None[int32]() + case 1: + + option1666 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyFutureType(option1666) + + case 36: + var option1667 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1667 = witTypes.None[int32]() + case 1: + + option1667 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1668 = golem_core_types.MakeSchemaTypeBodyStreamType(option1667) + + default: + panic("unreachable") + } + var option1670 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1670 = witTypes.None[string]() + case 1: + value1669 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1670 = witTypes.Some[string](value1669) + default: + panic("unreachable") + } + result1672 := 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)) + 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) + } + + result1674 := 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)) + value1673 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1674 = append(result1674, value1673) + } + + var option1676 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1676 = witTypes.None[string]() + case 1: + value1675 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1676 = witTypes.Some[string](value1675) + default: + panic("unreachable") + } + var option1679 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1679 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1678 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1678 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1678 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1678 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1677 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1678 = golem_core_types.MakeRoleOther(value1677) + + default: + panic("unreachable") + } + + option1679 = witTypes.Some[golem_core_types.Role](variant1678) + default: + panic("unreachable") + } + + result1680 = append(result1680, golem_core_types.SchemaTypeNode{variant1668, golem_core_types.MetadataEnvelope{option1670, result1672, result1674, option1676, option1679}}) + } + + result1684 := 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)) + value1681 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1683 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1683 = witTypes.None[string]() + case 1: + value1682 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1683 = witTypes.Some[string](value1682) + default: + panic("unreachable") + } + + result1684 = append(result1684, golem_core_types.SchemaTypeDef{value1681, option1683, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1708 := 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 variant1707 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1707 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1707 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1707 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1707 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1707 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1707 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1707 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1707 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1707 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1707 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1707 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1707 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1685 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1707 = golem_core_types.MakeSchemaValueNodeStringValue(value1685) + + case 13: + result1686 := 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) + + result1686 = append(result1686, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1707 = golem_core_types.MakeSchemaValueNodeRecordValue(result1686) + + case 14: + var option1687 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1687 = witTypes.None[int32]() + case 1: + + option1687 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1707 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1687}) + + case 15: + + variant1707 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1688 := 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) + + result1688 = append(result1688, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1707 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1688) + + case 17: + 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))) + } + + variant1707 = golem_core_types.MakeSchemaValueNodeTupleValue(result1689) + + case 18: + result1690 := 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) + + result1690 = append(result1690, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1707 = golem_core_types.MakeSchemaValueNodeListValue(result1690) + + case 19: + result1691 := 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) + + result1691 = append(result1691, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1707 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1691) + + case 20: + result1692 := 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) + + result1692 = append(result1692, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1707 = golem_core_types.MakeSchemaValueNodeMapValue(result1692) + + case 21: + var option1693 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1693 = witTypes.None[int32]() + case 1: + + option1693 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1707 = golem_core_types.MakeSchemaValueNodeOptionValue(option1693) + + case 22: + var variant1696 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1694 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1694 = witTypes.None[int32]() + case 1: + + option1694 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1696 = golem_core_types.MakeResultValuePayloadOkValue(option1694) + + case 1: + var option1695 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1695 = witTypes.None[int32]() + case 1: + + option1695 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1696 = golem_core_types.MakeResultValuePayloadErrValue(option1695) + + default: + panic("unreachable") + } + + variant1707 = golem_core_types.MakeSchemaValueNodeResultValue(variant1696) + + case 23: + value1697 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1699 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1699 = witTypes.None[string]() + case 1: + value1698 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1699 = witTypes.Some[string](value1698) + default: + panic("unreachable") + } + + variant1707 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1697, option1699}) + + case 24: + value1700 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1702 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1702 = witTypes.None[string]() + case 1: + value1701 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1702 = witTypes.Some[string](value1701) + default: + panic("unreachable") + } + + variant1707 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1700, option1702}) + + case 25: + value1703 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1707 = golem_core_types.MakeSchemaValueNodePathValue(value1703) + + case 26: + value1704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1707 = golem_core_types.MakeSchemaValueNodeUrlValue(value1704) + + case 27: + + variant1707 = 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: + + variant1707 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1705 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1707 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1705}) + + case 30: + value1706 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1707 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1706, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1707 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1707 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1707 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1708 = append(result1708, variant1707) + } + + variant1919 = MakeAgentInvocationResultAgentInitialization(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1680, result1684, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1708, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}}) + + case 1: + result1884 := 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 variant1872 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1872 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1872 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1715 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1715 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1710 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1709 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1709 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1709 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1710 = witTypes.Some[golem_core_types.NumericBound](variant1709) + default: + panic("unreachable") + } + var option1712 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1712 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1711 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1711 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1711 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1711 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1712 = witTypes.Some[golem_core_types.NumericBound](variant1711) + default: + panic("unreachable") + } + var option1714 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1714 = witTypes.None[string]() + case 1: + value1713 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1714 = witTypes.Some[string](value1713) + default: + panic("unreachable") + } + + option1715 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1710, option1712, option1714}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyS8Type(option1715) + + case 3: + var option1722 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1722 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1717 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1716 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1716 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1716 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1717 = witTypes.Some[golem_core_types.NumericBound](variant1716) + default: + panic("unreachable") + } + var option1719 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1719 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1718 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1718 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1718 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1718 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1719 = witTypes.Some[golem_core_types.NumericBound](variant1718) + default: + panic("unreachable") + } + var option1721 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1721 = witTypes.None[string]() + case 1: + value1720 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1721 = witTypes.Some[string](value1720) + default: + panic("unreachable") + } + + option1722 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1717, option1719, option1721}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyS16Type(option1722) + + case 4: + var option1729 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1729 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1724 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1723 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1723 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1723 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1724 = witTypes.Some[golem_core_types.NumericBound](variant1723) + default: + panic("unreachable") + } + var option1726 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1726 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1725 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1725 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1725 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1725 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1726 = witTypes.Some[golem_core_types.NumericBound](variant1725) + default: + panic("unreachable") + } + var option1728 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1728 = witTypes.None[string]() + case 1: + value1727 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1728 = witTypes.Some[string](value1727) + default: + panic("unreachable") + } + + option1729 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1724, option1726, option1728}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyS32Type(option1729) + + case 5: + var option1736 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1736 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1731 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1730 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1730 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1730 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1731 = witTypes.Some[golem_core_types.NumericBound](variant1730) + default: + panic("unreachable") + } + var option1733 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1733 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1732 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1732 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1732 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1732 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1733 = witTypes.Some[golem_core_types.NumericBound](variant1732) + default: + panic("unreachable") + } + var option1735 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1735 = witTypes.None[string]() + case 1: + value1734 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1735 = witTypes.Some[string](value1734) + default: + panic("unreachable") + } + + option1736 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1731, option1733, option1735}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyS64Type(option1736) + + case 6: + var option1743 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1743 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1738 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1737 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1737 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1737 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1738 = witTypes.Some[golem_core_types.NumericBound](variant1737) + default: + panic("unreachable") + } + var option1740 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1740 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1739 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1739 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1739 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1739 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1740 = witTypes.Some[golem_core_types.NumericBound](variant1739) + default: + panic("unreachable") + } + var option1742 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1742 = witTypes.None[string]() + case 1: + value1741 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1742 = witTypes.Some[string](value1741) + default: + panic("unreachable") + } + + option1743 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1738, option1740, option1742}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyU8Type(option1743) + + case 7: + var option1750 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1750 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1745 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1744 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1744 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1744 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1745 = witTypes.Some[golem_core_types.NumericBound](variant1744) + default: + panic("unreachable") + } + var option1747 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1747 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1746 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1746 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1746 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1746 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1747 = witTypes.Some[golem_core_types.NumericBound](variant1746) + default: + panic("unreachable") + } + var option1749 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1749 = witTypes.None[string]() + case 1: + value1748 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1749 = witTypes.Some[string](value1748) + default: + panic("unreachable") + } + + option1750 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1745, option1747, option1749}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyU16Type(option1750) + + case 8: + var option1757 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1757 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1752 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1751 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1751 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1751 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1752 = witTypes.Some[golem_core_types.NumericBound](variant1751) + default: + panic("unreachable") + } + var option1754 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1754 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1753 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1753 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1753 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1753 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1754 = witTypes.Some[golem_core_types.NumericBound](variant1753) + default: + panic("unreachable") + } + var option1756 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1756 = witTypes.None[string]() + case 1: + value1755 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1756 = witTypes.Some[string](value1755) + default: + panic("unreachable") + } + + option1757 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1752, option1754, option1756}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyU32Type(option1757) + + case 9: + var option1764 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1764 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1759 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1758 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1758 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1758 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1759 = witTypes.Some[golem_core_types.NumericBound](variant1758) + default: + panic("unreachable") + } + var option1761 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1761 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1760 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1760 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1760 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1760 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1761 = witTypes.Some[golem_core_types.NumericBound](variant1760) + default: + panic("unreachable") + } + var option1763 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1763 = witTypes.None[string]() + case 1: + value1762 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1763 = witTypes.Some[string](value1762) + default: + panic("unreachable") + } + + option1764 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1759, option1761, option1763}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyU64Type(option1764) + + case 10: + var option1771 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1771 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1766 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1765 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1765 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1765 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1766 = witTypes.Some[golem_core_types.NumericBound](variant1765) + default: + panic("unreachable") + } + var option1768 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1768 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1767 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1767 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1767 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1767 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1768 = witTypes.Some[golem_core_types.NumericBound](variant1767) + default: + panic("unreachable") + } + var option1770 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1770 = witTypes.None[string]() + case 1: + value1769 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1770 = witTypes.Some[string](value1769) + default: + panic("unreachable") + } + + option1771 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1766, option1768, option1770}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyF32Type(option1771) + + case 11: + var option1778 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1778 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1773 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1772 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1772 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1772 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1773 = witTypes.Some[golem_core_types.NumericBound](variant1772) + default: + panic("unreachable") + } + var option1775 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1775 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1774 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1774 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1774 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1774 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1775 = witTypes.Some[golem_core_types.NumericBound](variant1774) + default: + panic("unreachable") + } + var option1777 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1777 = witTypes.None[string]() + case 1: + value1776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1777 = witTypes.Some[string](value1776) + default: + panic("unreachable") + } + + option1778 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1773, option1775, option1777}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyF64Type(option1778) + + case 12: + + variant1872 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1872 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1791 := 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)) + value1779 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1781 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1781 = witTypes.None[string]() + case 1: + value1780 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1781 = witTypes.Some[string](value1780) + default: + panic("unreachable") + } + result1783 := 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)) + 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) + } + + result1785 := 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)) + value1784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1785 = append(result1785, value1784) + } + + var option1787 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1787 = witTypes.None[string]() + case 1: + value1786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1787 = witTypes.Some[string](value1786) + default: + panic("unreachable") + } + var option1790 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1790 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1789 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1789 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1789 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1789 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1789 = golem_core_types.MakeRoleOther(value1788) + + default: + panic("unreachable") + } + + option1790 = witTypes.Some[golem_core_types.Role](variant1789) + default: + panic("unreachable") + } + + result1791 = append(result1791, golem_core_types.NamedFieldType{value1779, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1781, result1783, result1785, option1787, option1790}}) + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyRecordType(result1791) + + case 15: + result1805 := 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)) + value1792 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1793 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1793 = witTypes.None[int32]() + case 1: + + option1793 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1795 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1795 = witTypes.None[string]() + case 1: + value1794 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1795 = witTypes.Some[string](value1794) + default: + panic("unreachable") + } + result1797 := 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)) + 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) + } + + result1799 := 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)) + value1798 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1799 = append(result1799, value1798) + } + + var option1801 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1801 = witTypes.None[string]() + case 1: + value1800 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1801 = witTypes.Some[string](value1800) + default: + panic("unreachable") + } + var option1804 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1804 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1803 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1803 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1803 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1803 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1802 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1803 = golem_core_types.MakeRoleOther(value1802) + + default: + panic("unreachable") + } + + option1804 = witTypes.Some[golem_core_types.Role](variant1803) + default: + panic("unreachable") + } + + result1805 = append(result1805, golem_core_types.VariantCaseType{value1792, option1793, golem_core_types.MetadataEnvelope{option1795, result1797, result1799, option1801, option1804}}) + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyVariantType(result1805) + + case 16: + 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) + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyEnumType(result1807) + + case 17: + result1809 := 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)) + value1808 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1809 = append(result1809, value1808) + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1809) + + case 18: + result1810 := 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) + + result1810 = append(result1810, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyTupleType(result1810) + + case 19: + + variant1872 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1872 = 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: + + variant1872 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1872 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1811 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1811 = witTypes.None[int32]() + case 1: + + option1811 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1812 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1812 = witTypes.None[int32]() + case 1: + + option1812 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1811, option1812}) + + case 24: + var option1815 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1815 = witTypes.None[[]string]() + case 1: + result1814 := 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)) + value1813 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1814 = append(result1814, value1813) + } + + option1815 = witTypes.Some[[]string](result1814) + default: + panic("unreachable") + } + var option1816 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1816 = witTypes.None[uint32]() + case 1: + + option1816 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1817 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1817 = witTypes.None[uint32]() + case 1: + + option1817 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1819 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1819 = witTypes.None[string]() + case 1: + value1818 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1819 = witTypes.Some[string](value1818) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1815, option1816, option1817, option1819}) + + case 25: + var option1822 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1822 = witTypes.None[[]string]() + case 1: + result1821 := 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)) + value1820 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1821 = append(result1821, value1820) + } + + option1822 = witTypes.Some[[]string](result1821) + default: + panic("unreachable") + } + var option1823 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1823 = witTypes.None[uint32]() + case 1: + + option1823 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1824 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1824 = witTypes.None[uint32]() + case 1: + + option1824 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1822, option1823, option1824}) + + case 26: + var option1827 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1827 = witTypes.None[[]string]() + case 1: + result1826 := 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)) + 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 + 4*4)))) { + case 0: + + option1830 = witTypes.None[[]string]() + case 1: + result1829 := 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)) + 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") + } + + variant1872 = 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)))), option1827, option1830}) + + case 27: + var option1833 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1833 = witTypes.None[[]string]() + case 1: + result1832 := 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)) + value1831 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1832 = append(result1832, value1831) + } + + option1833 = witTypes.Some[[]string](result1832) + default: + panic("unreachable") + } + var option1836 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1836 = witTypes.None[[]string]() + case 1: + result1835 := 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)) + value1834 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1835 = append(result1835, value1834) + } + + option1836 = witTypes.Some[[]string](result1835) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1833, option1836}) + + case 28: + + variant1872 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1872 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1837 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1839 := 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)) + value1838 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1839 = append(result1839, value1838) + } + + var option1841 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1841 = 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))), value1840}) + default: + panic("unreachable") + } + var option1843 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1843 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1842 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1843 = 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))), value1842}) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1837, result1839, option1841, option1843}) + + case 31: + result1865 := 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)) + value1844 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1853 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1845 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1853 = golem_core_types.MakeDiscriminatorRulePrefix(value1845) + + case 1: + value1846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1853 = golem_core_types.MakeDiscriminatorRuleSuffix(value1846) + + case 2: + value1847 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1853 = golem_core_types.MakeDiscriminatorRuleContains(value1847) + + case 3: + value1848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1853 = golem_core_types.MakeDiscriminatorRuleRegex(value1848) + + case 4: + value1849 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1851 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1851 = witTypes.None[string]() + case 1: + value1850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1851 = witTypes.Some[string](value1850) + default: + panic("unreachable") + } + + variant1853 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1849, option1851}) + + case 5: + value1852 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1853 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1852) + + default: + panic("unreachable") + } + var option1855 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1855 = witTypes.None[string]() + case 1: + value1854 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1855 = witTypes.Some[string](value1854) + default: + panic("unreachable") + } + result1857 := 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)) + 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) + } + + result1859 := 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)) + value1858 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1859 = append(result1859, value1858) + } + + var option1861 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1861 = witTypes.None[string]() + case 1: + value1860 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1861 = witTypes.Some[string](value1860) + default: + panic("unreachable") + } + var option1864 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1864 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1863 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1863 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1863 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1863 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1862 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1863 = golem_core_types.MakeRoleOther(value1862) + + default: + panic("unreachable") + } + + option1864 = witTypes.Some[golem_core_types.Role](variant1863) + default: + panic("unreachable") + } + + result1865 = append(result1865, golem_core_types.UnionBranch{value1844, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1853, golem_core_types.MetadataEnvelope{option1855, result1857, result1859, option1861, option1864}}) + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1865}) + + case 32: + var option1867 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1867 = witTypes.None[string]() + case 1: + value1866 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1867 = witTypes.Some[string](value1866) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1867}) + + case 33: + var option1869 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1869 = witTypes.None[string]() + case 1: + value1868 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1869 = witTypes.Some[string](value1868) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1869}) + + case 34: + + variant1872 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1870 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1870 = witTypes.None[int32]() + case 1: + + option1870 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyFutureType(option1870) + + case 36: + var option1871 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1871 = witTypes.None[int32]() + case 1: + + option1871 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1872 = golem_core_types.MakeSchemaTypeBodyStreamType(option1871) + + default: + panic("unreachable") + } + var option1874 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1874 = witTypes.None[string]() + case 1: + value1873 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1874 = witTypes.Some[string](value1873) + default: + panic("unreachable") + } + result1876 := 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)) + 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) + } + + result1878 := 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)) + value1877 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1878 = append(result1878, value1877) + } + + var option1880 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1880 = witTypes.None[string]() + case 1: + value1879 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1880 = witTypes.Some[string](value1879) + default: + panic("unreachable") + } + var option1883 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1883 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1882 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1882 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1882 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1882 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1881 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1882 = golem_core_types.MakeRoleOther(value1881) + + default: + panic("unreachable") + } + + option1883 = witTypes.Some[golem_core_types.Role](variant1882) + default: + panic("unreachable") + } + + result1884 = append(result1884, golem_core_types.SchemaTypeNode{variant1872, golem_core_types.MetadataEnvelope{option1874, result1876, result1878, option1880, option1883}}) + } + + result1888 := 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)) + value1885 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1887 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1887 = witTypes.None[string]() + case 1: + value1886 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1887 = witTypes.Some[string](value1886) + default: + panic("unreachable") + } + + result1888 = append(result1888, golem_core_types.SchemaTypeDef{value1885, option1887, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1912 := 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 variant1911 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1911 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1911 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1911 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1911 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1911 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1911 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1911 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1911 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1911 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1911 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1911 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1911 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1889 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1911 = golem_core_types.MakeSchemaValueNodeStringValue(value1889) + + case 13: + result1890 := 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) + + result1890 = append(result1890, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1911 = golem_core_types.MakeSchemaValueNodeRecordValue(result1890) + + case 14: + var option1891 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1891 = witTypes.None[int32]() + case 1: + + option1891 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1911 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1891}) + + case 15: + + variant1911 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1892 := 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) + + result1892 = append(result1892, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1911 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1892) + + case 17: + 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))) + } + + variant1911 = golem_core_types.MakeSchemaValueNodeTupleValue(result1893) + + case 18: + result1894 := 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) + + result1894 = append(result1894, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1911 = golem_core_types.MakeSchemaValueNodeListValue(result1894) + + case 19: + result1895 := 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) + + result1895 = append(result1895, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1911 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1895) + + case 20: + result1896 := 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) + + result1896 = append(result1896, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1911 = golem_core_types.MakeSchemaValueNodeMapValue(result1896) + + case 21: + var option1897 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1897 = witTypes.None[int32]() + case 1: + + option1897 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1911 = golem_core_types.MakeSchemaValueNodeOptionValue(option1897) + + case 22: + var variant1900 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1898 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1898 = witTypes.None[int32]() + case 1: + + option1898 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1900 = golem_core_types.MakeResultValuePayloadOkValue(option1898) + + case 1: + var option1899 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1899 = witTypes.None[int32]() + case 1: + + option1899 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1900 = golem_core_types.MakeResultValuePayloadErrValue(option1899) + + default: + panic("unreachable") + } + + variant1911 = golem_core_types.MakeSchemaValueNodeResultValue(variant1900) + + case 23: + value1901 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1903 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1903 = witTypes.None[string]() + case 1: + value1902 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1903 = witTypes.Some[string](value1902) + default: + panic("unreachable") + } + + variant1911 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1901, option1903}) + + case 24: + value1904 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1906 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1906 = witTypes.None[string]() + case 1: + value1905 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1906 = witTypes.Some[string](value1905) + default: + panic("unreachable") + } + + variant1911 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1904, option1906}) + + case 25: + value1907 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1911 = golem_core_types.MakeSchemaValueNodePathValue(value1907) + + case 26: + value1908 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1911 = golem_core_types.MakeSchemaValueNodeUrlValue(value1908) + + case 27: + + variant1911 = 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: + + variant1911 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1909 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1911 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1909}) + + case 30: + value1910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1911 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1910, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1911 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1911 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1911 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1912 = append(result1912, variant1911) + } + + variant1919 = MakeAgentInvocationResultAgentMethod(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1884, result1888, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1912, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}}) + + case 2: + + variant1919 = MakeAgentInvocationResultManualUpdate() + + case 3: + var option1914 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) { + case 0: + + option1914 = witTypes.None[string]() + case 1: + value1913 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) + + option1914 = witTypes.Some[string](value1913) + default: + panic("unreachable") + } + + variant1919 = MakeAgentInvocationResultLoadSnapshot(FallibleResultParameters{option1914}) + + case 4: + value1915 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) + value1916 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + variant1919 = MakeAgentInvocationResultSaveSnapshot(SaveSnapshotResultParameters{SnapshotData{value1915, value1916}}) + + case 5: + var option1918 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) { + case 0: + + option1918 = witTypes.None[string]() + case 1: + value1917 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) + + option1918 = witTypes.Some[string](value1917) + default: + panic("unreachable") + } + + variant1919 = MakeAgentInvocationResultProcessOplogEntries(FallibleResultParameters{option1918}) + + default: + panic("unreachable") + } + var option1921 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4)))) { + case 0: + + option1921 = witTypes.None[string]() + case 1: + value1920 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 11*4)))) + + option1921 = witTypes.Some[string](value1920) + default: + panic("unreachable") + } + + variant2694 = 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)))}, variant1919, option1921, *(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))}) + + case 6: + + variant2694 = 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: + value1922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + var option1925 witTypes.Option[RetryPolicyState] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) { + case 0: + + option1925 = witTypes.None[RetryPolicyState]() + case 1: + result1924 := 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 variant1923 StateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1923 = MakeStateNodeCounter(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)))) + + case 1: + + variant1923 = MakeStateNodeTerminal() + + case 2: + + variant1923 = MakeStateNodeWrapper(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))) + + case 3: + + variant1923 = MakeStateNodeCountBox(CountBoxState{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 4: + + variant1923 = 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: + + variant1923 = MakeStateNodePair(PairState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))}) + + default: + panic("unreachable") + } + + result1924 = append(result1924, variant1923) + } + + option1925 = witTypes.Some[RetryPolicyState](RetryPolicyState{result1924}) + default: + panic("unreachable") + } + + variant2694 = 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)))}, value1922, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) != 0), option1925}) + + case 8: + + variant2694 = 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: + + variant2694 = 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: + + variant2694 = 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: + + variant2694 = 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: + + variant2694 = 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: + + variant2694 = 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 variant2370 AgentInvocation + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + value1926 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + result2102 := 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 variant2090 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2090 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant2090 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1933 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1933 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1928 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1927 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1927 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1927 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1928 = witTypes.Some[golem_core_types.NumericBound](variant1927) + default: + panic("unreachable") + } + var option1930 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1930 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1929 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1929 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1929 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1929 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1930 = witTypes.Some[golem_core_types.NumericBound](variant1929) + default: + panic("unreachable") + } + var option1932 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1932 = witTypes.None[string]() + case 1: + value1931 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1932 = witTypes.Some[string](value1931) + default: + panic("unreachable") + } + + option1933 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1928, option1930, option1932}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyS8Type(option1933) + + case 3: + var option1940 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1940 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1935 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1934 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1934 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1934 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1935 = witTypes.Some[golem_core_types.NumericBound](variant1934) + default: + panic("unreachable") + } + var option1937 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1937 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1936 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1936 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1936 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1936 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1937 = witTypes.Some[golem_core_types.NumericBound](variant1936) + default: + panic("unreachable") + } + var option1939 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1939 = witTypes.None[string]() + case 1: + value1938 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1939 = witTypes.Some[string](value1938) + default: + panic("unreachable") + } + + option1940 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1935, option1937, option1939}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyS16Type(option1940) + + case 4: + var option1947 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1947 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1942 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1941 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1941 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1941 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1942 = witTypes.Some[golem_core_types.NumericBound](variant1941) + default: + panic("unreachable") + } + var option1944 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1944 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1943 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1943 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1943 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1943 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1944 = witTypes.Some[golem_core_types.NumericBound](variant1943) + default: + panic("unreachable") + } + var option1946 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1946 = witTypes.None[string]() + case 1: + value1945 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1946 = witTypes.Some[string](value1945) + default: + panic("unreachable") + } + + option1947 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1942, option1944, option1946}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyS32Type(option1947) + + case 5: + var option1954 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1954 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1949 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1948 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1948 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1948 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1949 = witTypes.Some[golem_core_types.NumericBound](variant1948) + default: + panic("unreachable") + } + var option1951 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1951 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1950 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1950 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1950 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1950 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1951 = witTypes.Some[golem_core_types.NumericBound](variant1950) + default: + panic("unreachable") + } + var option1953 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1953 = witTypes.None[string]() + case 1: + value1952 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1953 = witTypes.Some[string](value1952) + default: + panic("unreachable") + } + + option1954 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1949, option1951, option1953}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyS64Type(option1954) + + case 6: + var option1961 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1961 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1956 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1955 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1955 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1955 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1956 = witTypes.Some[golem_core_types.NumericBound](variant1955) + default: + panic("unreachable") + } + var option1958 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1958 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1957 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1957 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1957 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1957 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1958 = witTypes.Some[golem_core_types.NumericBound](variant1957) + default: + panic("unreachable") + } + var option1960 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1960 = witTypes.None[string]() + case 1: + value1959 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1960 = witTypes.Some[string](value1959) + default: + panic("unreachable") + } + + option1961 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1956, option1958, option1960}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyU8Type(option1961) + + case 7: + var option1968 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1968 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1963 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1962 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1962 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1962 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1963 = witTypes.Some[golem_core_types.NumericBound](variant1962) + default: + panic("unreachable") + } + var option1965 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1965 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1964 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1964 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1964 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1964 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1965 = witTypes.Some[golem_core_types.NumericBound](variant1964) + default: + panic("unreachable") + } + var option1967 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1967 = witTypes.None[string]() + case 1: + value1966 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1967 = witTypes.Some[string](value1966) + default: + panic("unreachable") + } + + option1968 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1963, option1965, option1967}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyU16Type(option1968) + + case 8: + var option1975 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1975 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1970 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1969 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1969 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1969 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1970 = witTypes.Some[golem_core_types.NumericBound](variant1969) + default: + panic("unreachable") + } + var option1972 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1972 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1971 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1971 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1971 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1971 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1972 = witTypes.Some[golem_core_types.NumericBound](variant1971) + default: + panic("unreachable") + } + var option1974 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1974 = witTypes.None[string]() + case 1: + value1973 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1974 = witTypes.Some[string](value1973) + default: + panic("unreachable") + } + + option1975 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1970, option1972, option1974}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyU32Type(option1975) + + case 9: + var option1982 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1982 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1977 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1976 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1976 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1976 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1977 = witTypes.Some[golem_core_types.NumericBound](variant1976) + default: + panic("unreachable") + } + var option1979 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1979 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1978 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1978 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1978 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1978 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1979 = witTypes.Some[golem_core_types.NumericBound](variant1978) + default: + panic("unreachable") + } + var option1981 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1981 = witTypes.None[string]() + case 1: + value1980 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1981 = witTypes.Some[string](value1980) + default: + panic("unreachable") + } + + option1982 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1977, option1979, option1981}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyU64Type(option1982) + + case 10: + var option1989 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1989 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1984 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1983 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1983 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1983 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1984 = witTypes.Some[golem_core_types.NumericBound](variant1983) + default: + panic("unreachable") + } + var option1986 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1986 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1985 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1985 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1985 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1985 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1986 = witTypes.Some[golem_core_types.NumericBound](variant1985) + default: + panic("unreachable") + } + var option1988 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1988 = witTypes.None[string]() + case 1: + value1987 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1988 = witTypes.Some[string](value1987) + default: + panic("unreachable") + } + + option1989 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1984, option1986, option1988}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyF32Type(option1989) + + case 11: + var option1996 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1996 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1991 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1990 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1990 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1990 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1991 = witTypes.Some[golem_core_types.NumericBound](variant1990) + default: + panic("unreachable") + } + var option1993 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1993 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1992 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1992 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1992 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1992 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1993 = witTypes.Some[golem_core_types.NumericBound](variant1992) + default: + panic("unreachable") + } + var option1995 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1995 = witTypes.None[string]() + case 1: + value1994 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1995 = witTypes.Some[string](value1994) + default: + panic("unreachable") + } + + option1996 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1991, option1993, option1995}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyF64Type(option1996) + + case 12: + + variant2090 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant2090 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result2009 := 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)) + value1997 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1999 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1999 = witTypes.None[string]() + case 1: + value1998 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1999 = witTypes.Some[string](value1998) + default: + panic("unreachable") + } + result2001 := 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)) + 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) + } + + result2003 := 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)) + value2002 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2003 = append(result2003, value2002) + } + + var option2005 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option2005 = witTypes.None[string]() + case 1: + value2004 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option2005 = witTypes.Some[string](value2004) + default: + panic("unreachable") + } + var option2008 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option2008 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2007 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant2007 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2007 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2007 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2006 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant2007 = golem_core_types.MakeRoleOther(value2006) + + default: + panic("unreachable") + } + + option2008 = witTypes.Some[golem_core_types.Role](variant2007) + default: + panic("unreachable") + } + + result2009 = append(result2009, golem_core_types.NamedFieldType{value1997, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1999, result2001, result2003, option2005, option2008}}) + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyRecordType(result2009) + + case 15: + result2023 := 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)) + value2010 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2011 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2011 = witTypes.None[int32]() + case 1: + + option2011 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option2013 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2013 = witTypes.None[string]() + case 1: + value2012 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2013 = witTypes.Some[string](value2012) + default: + panic("unreachable") + } + result2015 := 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)) + 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) + } + + result2017 := 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)) + value2016 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2017 = append(result2017, value2016) + } + + var option2019 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option2019 = witTypes.None[string]() + case 1: + value2018 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option2019 = witTypes.Some[string](value2018) + default: + panic("unreachable") + } + var option2022 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option2022 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2021 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant2021 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2021 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2021 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2020 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant2021 = golem_core_types.MakeRoleOther(value2020) + + default: + panic("unreachable") + } + + option2022 = witTypes.Some[golem_core_types.Role](variant2021) + default: + panic("unreachable") + } + + result2023 = append(result2023, golem_core_types.VariantCaseType{value2010, option2011, golem_core_types.MetadataEnvelope{option2013, result2015, result2017, option2019, option2022}}) + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyVariantType(result2023) + + case 16: + 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) + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyEnumType(result2025) + + case 17: + result2027 := 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)) + value2026 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2027 = append(result2027, value2026) + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2027) + + case 18: + result2028 := 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) + + result2028 = append(result2028, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyTupleType(result2028) + + case 19: + + variant2090 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant2090 = 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: + + variant2090 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant2090 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option2029 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2029 = witTypes.None[int32]() + case 1: + + option2029 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option2030 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2030 = witTypes.None[int32]() + case 1: + + option2030 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2029, option2030}) + + case 24: + var option2033 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2033 = witTypes.None[[]string]() + case 1: + result2032 := 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)) + value2031 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2032 = append(result2032, value2031) + } + + option2033 = witTypes.Some[[]string](result2032) + default: + panic("unreachable") + } + var option2034 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2034 = witTypes.None[uint32]() + case 1: + + option2034 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2035 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2035 = witTypes.None[uint32]() + case 1: + + option2035 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option2037 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option2037 = witTypes.None[string]() + case 1: + value2036 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option2037 = witTypes.Some[string](value2036) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2033, option2034, option2035, option2037}) + + case 25: + var option2040 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2040 = witTypes.None[[]string]() + case 1: + result2039 := 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)) + value2038 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2039 = append(result2039, value2038) + } + + option2040 = witTypes.Some[[]string](result2039) + default: + panic("unreachable") + } + var option2041 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2041 = witTypes.None[uint32]() + case 1: + + option2041 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2042 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2042 = witTypes.None[uint32]() + case 1: + + option2042 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2040, option2041, option2042}) + + case 26: + var option2045 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2045 = witTypes.None[[]string]() + case 1: + result2044 := 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)) + 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") + } + var option2048 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2048 = witTypes.None[[]string]() + case 1: + result2047 := 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)) + 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") + } + + variant2090 = 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)))), option2045, option2048}) + + case 27: + var option2051 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2051 = witTypes.None[[]string]() + case 1: + result2050 := 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)) + 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") + } + var option2054 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2054 = witTypes.None[[]string]() + case 1: + result2053 := 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)) + value2052 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2053 = append(result2053, value2052) + } + + option2054 = witTypes.Some[[]string](result2053) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2051, option2054}) + + case 28: + + variant2090 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant2090 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value2055 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2057 := 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)) + value2056 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2057 = append(result2057, value2056) + } + + var option2059 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option2059 = 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))), value2058}) + default: + panic("unreachable") + } + var option2061 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option2061 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2060 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option2061 = 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))), value2060}) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2055, result2057, option2059, option2061}) + + case 31: + result2083 := 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)) + value2062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2071 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value2063 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2071 = golem_core_types.MakeDiscriminatorRulePrefix(value2063) + + case 1: + value2064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2071 = golem_core_types.MakeDiscriminatorRuleSuffix(value2064) + + case 2: + value2065 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2071 = golem_core_types.MakeDiscriminatorRuleContains(value2065) + + case 3: + value2066 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2071 = golem_core_types.MakeDiscriminatorRuleRegex(value2066) + + case 4: + value2067 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option2069 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option2069 = witTypes.None[string]() + case 1: + value2068 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option2069 = witTypes.Some[string](value2068) + default: + panic("unreachable") + } + + variant2071 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2067, option2069}) + + case 5: + value2070 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2071 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2070) + + default: + panic("unreachable") + } + var option2073 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option2073 = witTypes.None[string]() + case 1: + value2072 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option2073 = witTypes.Some[string](value2072) + default: + panic("unreachable") + } + result2075 := 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)) + 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) + } + + result2077 := 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)) + value2076 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2077 = append(result2077, value2076) + } + + var option2079 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option2079 = witTypes.None[string]() + case 1: + value2078 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option2079 = witTypes.Some[string](value2078) + default: + panic("unreachable") + } + var option2082 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option2082 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2081 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant2081 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2081 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2081 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2080 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant2081 = golem_core_types.MakeRoleOther(value2080) + + default: + panic("unreachable") + } + + option2082 = witTypes.Some[golem_core_types.Role](variant2081) + default: + panic("unreachable") + } + + result2083 = append(result2083, golem_core_types.UnionBranch{value2062, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2071, golem_core_types.MetadataEnvelope{option2073, result2075, result2077, option2079, option2082}}) + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2083}) + + case 32: + var option2085 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2085 = witTypes.None[string]() + case 1: + value2084 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option2085 = witTypes.Some[string](value2084) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2085}) + + case 33: + var option2087 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2087 = witTypes.None[string]() + case 1: + value2086 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option2087 = witTypes.Some[string](value2086) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2087}) + + case 34: + + variant2090 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option2088 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2088 = witTypes.None[int32]() + case 1: + + option2088 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyFutureType(option2088) + + case 36: + var option2089 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2089 = witTypes.None[int32]() + case 1: + + option2089 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2090 = golem_core_types.MakeSchemaTypeBodyStreamType(option2089) + + default: + panic("unreachable") + } + var option2092 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option2092 = witTypes.None[string]() + case 1: + value2091 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option2092 = witTypes.Some[string](value2091) + default: + panic("unreachable") + } + result2094 := 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)) + 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) + } + + result2096 := 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)) + value2095 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2096 = append(result2096, value2095) + } + + var option2098 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option2098 = witTypes.None[string]() + case 1: + value2097 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option2098 = witTypes.Some[string](value2097) + default: + panic("unreachable") + } + var option2101 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option2101 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2100 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant2100 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2100 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2100 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2099 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant2100 = golem_core_types.MakeRoleOther(value2099) + + default: + panic("unreachable") + } + + option2101 = witTypes.Some[golem_core_types.Role](variant2100) + default: + panic("unreachable") + } + + result2102 = append(result2102, golem_core_types.SchemaTypeNode{variant2090, golem_core_types.MetadataEnvelope{option2092, result2094, result2096, option2098, option2101}}) + } + + result2106 := 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)) + value2103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2105 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2105 = witTypes.None[string]() + case 1: + value2104 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option2105 = witTypes.Some[string](value2104) + default: + panic("unreachable") + } + + result2106 = append(result2106, golem_core_types.SchemaTypeDef{value2103, option2105, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result2130 := 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 variant2129 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2129 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant2129 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant2129 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant2129 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant2129 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant2129 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant2129 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant2129 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant2129 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant2129 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant2129 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant2129 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value2107 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2129 = golem_core_types.MakeSchemaValueNodeStringValue(value2107) + + case 13: + 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))) + } + + variant2129 = golem_core_types.MakeSchemaValueNodeRecordValue(result2108) + + case 14: + var option2109 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2109 = witTypes.None[int32]() + case 1: + + option2109 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2129 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2109}) + + case 15: + + variant2129 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result2110 := 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) + + result2110 = append(result2110, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant2129 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2110) + + case 17: + 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))) + } + + variant2129 = golem_core_types.MakeSchemaValueNodeTupleValue(result2111) + + case 18: + result2112 := 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) + + result2112 = append(result2112, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2129 = golem_core_types.MakeSchemaValueNodeListValue(result2112) + + case 19: + result2113 := 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) + + result2113 = append(result2113, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2129 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2113) + + case 20: + result2114 := 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) + + result2114 = append(result2114, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant2129 = golem_core_types.MakeSchemaValueNodeMapValue(result2114) + + case 21: + var option2115 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2115 = witTypes.None[int32]() + case 1: + + option2115 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2129 = golem_core_types.MakeSchemaValueNodeOptionValue(option2115) + + case 22: + var variant2118 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option2116 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2116 = witTypes.None[int32]() + case 1: + + option2116 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2118 = golem_core_types.MakeResultValuePayloadOkValue(option2116) + + case 1: + var option2117 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2117 = witTypes.None[int32]() + case 1: + + option2117 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2118 = golem_core_types.MakeResultValuePayloadErrValue(option2117) + + default: + panic("unreachable") + } + + variant2129 = golem_core_types.MakeSchemaValueNodeResultValue(variant2118) + + case 23: + value2119 := unsafe.String((*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") + } + + variant2129 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2119, option2121}) + + case 24: + value2122 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2124 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2124 = witTypes.None[string]() + case 1: + value2123 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2124 = witTypes.Some[string](value2123) + default: + panic("unreachable") + } + + variant2129 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2122, option2124}) + + case 25: + value2125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2129 = golem_core_types.MakeSchemaValueNodePathValue(value2125) + + case 26: + value2126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2129 = golem_core_types.MakeSchemaValueNodeUrlValue(value2126) + + case 27: + + variant2129 = 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: + + variant2129 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value2127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant2129 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2127}) + + case 30: + value2128 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2129 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2128, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant2129 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant2129 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant2129 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result2130 = append(result2130, variant2129) + } + + value2131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))) + result2133 := 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)) + value2132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2133 = append(result2133, value2132) + } + + result2145 := 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)) + result2144 := 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 variant2143 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2136 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option2136 = witTypes.None[string]() + case 1: + value2135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option2136 = witTypes.Some[string](value2135) + default: + panic("unreachable") + } + var option2137 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option2137 = witTypes.None[uint64]() + case 1: + + option2137 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result2141 := 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)) + value2138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2140 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value2139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant2140 = golem_api_context.MakeAttributeValueString(value2139) + + default: + panic("unreachable") + } + + result2141 = append(result2141, golem_api_context.Attribute{value2138, variant2140}) + } + + variant2143 = MakeSpanDataLocalSpan(LocalSpanData{value2134, 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))))}, option2136, option2137, result2141, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value2142 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2143 = MakeSpanDataExternalSpan(ExternalSpanData{value2142}) + + default: + panic("unreachable") + } + + result2144 = append(result2144, variant2143) + } + + result2145 = append(result2145, result2144) + } + + variant2370 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1926, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2102, result2106, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result2130, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value2131, result2133, result2145}) + + case 1: + value2146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value2147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + result2323 := 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 variant2311 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2311 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant2311 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option2154 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2154 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2149 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2148 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2148 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2148 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2149 = witTypes.Some[golem_core_types.NumericBound](variant2148) + default: + panic("unreachable") + } + var option2151 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2151 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2150 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2150 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2150 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2150 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2151 = witTypes.Some[golem_core_types.NumericBound](variant2150) + default: + panic("unreachable") + } + var option2153 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2153 = witTypes.None[string]() + case 1: + value2152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2153 = witTypes.Some[string](value2152) + default: + panic("unreachable") + } + + option2154 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2149, option2151, option2153}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyS8Type(option2154) + + case 3: + var option2161 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2161 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2156 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2155 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2155 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2155 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2156 = witTypes.Some[golem_core_types.NumericBound](variant2155) + default: + panic("unreachable") + } + var option2158 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2158 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2157 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2157 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2157 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2157 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2158 = witTypes.Some[golem_core_types.NumericBound](variant2157) + default: + panic("unreachable") + } + var option2160 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2160 = witTypes.None[string]() + case 1: + value2159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2160 = witTypes.Some[string](value2159) + default: + panic("unreachable") + } + + option2161 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2156, option2158, option2160}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyS16Type(option2161) + + case 4: + var option2168 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2168 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2163 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2162 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2162 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2162 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2163 = witTypes.Some[golem_core_types.NumericBound](variant2162) + default: + panic("unreachable") + } + var option2165 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2165 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2164 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2164 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2164 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2164 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2165 = witTypes.Some[golem_core_types.NumericBound](variant2164) + default: + panic("unreachable") + } + var option2167 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2167 = witTypes.None[string]() + case 1: + value2166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2167 = witTypes.Some[string](value2166) + default: + panic("unreachable") + } + + option2168 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2163, option2165, option2167}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyS32Type(option2168) + + case 5: + var option2175 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2175 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2170 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2169 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2169 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2169 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2170 = witTypes.Some[golem_core_types.NumericBound](variant2169) + default: + panic("unreachable") + } + var option2172 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2172 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2171 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2171 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2171 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2171 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2172 = witTypes.Some[golem_core_types.NumericBound](variant2171) + default: + panic("unreachable") + } + var option2174 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2174 = witTypes.None[string]() + case 1: + value2173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2174 = witTypes.Some[string](value2173) + default: + panic("unreachable") + } + + option2175 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2170, option2172, option2174}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyS64Type(option2175) + + case 6: + var option2182 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2182 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2177 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2176 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2176 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2176 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2177 = witTypes.Some[golem_core_types.NumericBound](variant2176) + default: + panic("unreachable") + } + var option2179 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2179 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2178 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2178 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2178 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2178 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2179 = witTypes.Some[golem_core_types.NumericBound](variant2178) + default: + panic("unreachable") + } + var option2181 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2181 = witTypes.None[string]() + case 1: + value2180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2181 = witTypes.Some[string](value2180) + default: + panic("unreachable") + } + + option2182 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2177, option2179, option2181}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyU8Type(option2182) + + case 7: + var option2189 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2189 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2184 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2183 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2183 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2183 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2184 = witTypes.Some[golem_core_types.NumericBound](variant2183) + default: + panic("unreachable") + } + var option2186 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2186 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2185 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2185 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2185 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2185 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2186 = witTypes.Some[golem_core_types.NumericBound](variant2185) + default: + panic("unreachable") + } + var option2188 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2188 = witTypes.None[string]() + case 1: + value2187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2188 = witTypes.Some[string](value2187) + default: + panic("unreachable") + } + + option2189 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2184, option2186, option2188}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyU16Type(option2189) + + case 8: + var option2196 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2196 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2191 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2190 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2190 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2190 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2191 = witTypes.Some[golem_core_types.NumericBound](variant2190) + default: + panic("unreachable") + } + var option2193 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2193 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2192 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2192 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2192 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2192 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2193 = witTypes.Some[golem_core_types.NumericBound](variant2192) + default: + panic("unreachable") + } + var option2195 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2195 = witTypes.None[string]() + case 1: + value2194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2195 = witTypes.Some[string](value2194) + default: + panic("unreachable") + } + + option2196 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2191, option2193, option2195}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyU32Type(option2196) + + case 9: + var option2203 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2203 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2198 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2197 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2197 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2197 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2198 = witTypes.Some[golem_core_types.NumericBound](variant2197) + default: + panic("unreachable") + } + var option2200 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2200 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2199 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2199 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2199 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2199 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2200 = witTypes.Some[golem_core_types.NumericBound](variant2199) + default: + panic("unreachable") + } + var option2202 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2202 = witTypes.None[string]() + case 1: + value2201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2202 = witTypes.Some[string](value2201) + default: + panic("unreachable") + } + + option2203 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2198, option2200, option2202}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyU64Type(option2203) + + case 10: + var option2210 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2210 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2205 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2204 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2204 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2204 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2205 = witTypes.Some[golem_core_types.NumericBound](variant2204) + default: + panic("unreachable") + } + var option2207 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2207 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2206 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2206 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2206 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2206 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2207 = witTypes.Some[golem_core_types.NumericBound](variant2206) + default: + panic("unreachable") + } + var option2209 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2209 = witTypes.None[string]() + case 1: + value2208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2209 = witTypes.Some[string](value2208) + default: + panic("unreachable") + } + + option2210 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2205, option2207, option2209}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyF32Type(option2210) + + case 11: + var option2217 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2217 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2212 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant2211 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2211 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2211 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2212 = witTypes.Some[golem_core_types.NumericBound](variant2211) + default: + panic("unreachable") + } + var option2214 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2214 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2213 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2213 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2213 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2213 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2214 = witTypes.Some[golem_core_types.NumericBound](variant2213) + default: + panic("unreachable") + } + var option2216 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2216 = witTypes.None[string]() + case 1: + value2215 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2216 = witTypes.Some[string](value2215) + default: + panic("unreachable") + } + + option2217 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2212, option2214, option2216}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyF64Type(option2217) + + case 12: + + variant2311 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant2311 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result2230 := 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)) + value2218 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2220 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option2220 = witTypes.None[string]() + case 1: + value2219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option2220 = witTypes.Some[string](value2219) + default: + panic("unreachable") + } + result2222 := 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)) + 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) + } + + result2224 := 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)) + value2223 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2224 = append(result2224, value2223) + } + + var option2226 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option2226 = witTypes.None[string]() + case 1: + value2225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option2226 = witTypes.Some[string](value2225) + default: + panic("unreachable") + } + var option2229 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option2229 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2228 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant2228 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2228 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2228 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant2228 = golem_core_types.MakeRoleOther(value2227) + + default: + panic("unreachable") + } + + option2229 = witTypes.Some[golem_core_types.Role](variant2228) + default: + panic("unreachable") + } + + result2230 = append(result2230, golem_core_types.NamedFieldType{value2218, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2220, result2222, result2224, option2226, option2229}}) + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyRecordType(result2230) + + case 15: + result2244 := 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)) + value2231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2232 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2232 = witTypes.None[int32]() + case 1: + + option2232 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option2234 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2234 = witTypes.None[string]() + case 1: + value2233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2234 = witTypes.Some[string](value2233) + default: + panic("unreachable") + } + result2236 := 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)) + 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) + } + + result2238 := 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)) + value2237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2238 = append(result2238, value2237) + } + + var option2240 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option2240 = witTypes.None[string]() + case 1: + value2239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option2240 = witTypes.Some[string](value2239) + default: + panic("unreachable") + } + var option2243 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option2243 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2242 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant2242 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2242 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2242 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2241 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant2242 = golem_core_types.MakeRoleOther(value2241) + + default: + panic("unreachable") + } + + option2243 = witTypes.Some[golem_core_types.Role](variant2242) + default: + panic("unreachable") + } + + result2244 = append(result2244, golem_core_types.VariantCaseType{value2231, option2232, golem_core_types.MetadataEnvelope{option2234, result2236, result2238, option2240, option2243}}) + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyVariantType(result2244) + + case 16: + 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) + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyEnumType(result2246) + + case 17: + result2248 := 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)) + value2247 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2248 = append(result2248, value2247) + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2248) + + case 18: + result2249 := 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) + + result2249 = append(result2249, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyTupleType(result2249) + + case 19: + + variant2311 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant2311 = 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: + + variant2311 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant2311 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option2250 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2250 = witTypes.None[int32]() + case 1: + + option2250 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option2251 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2251 = witTypes.None[int32]() + case 1: + + option2251 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2250, option2251}) + + case 24: + var option2254 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2254 = witTypes.None[[]string]() + case 1: + result2253 := 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)) + value2252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2253 = append(result2253, value2252) + } + + option2254 = witTypes.Some[[]string](result2253) + default: + panic("unreachable") + } + var option2255 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2255 = witTypes.None[uint32]() + case 1: + + option2255 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2256 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2256 = witTypes.None[uint32]() + case 1: + + option2256 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option2258 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option2258 = witTypes.None[string]() + case 1: + value2257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option2258 = witTypes.Some[string](value2257) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2254, option2255, option2256, option2258}) + + case 25: + var option2261 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2261 = witTypes.None[[]string]() + case 1: + result2260 := 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)) + value2259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2260 = append(result2260, value2259) + } + + option2261 = witTypes.Some[[]string](result2260) + default: + panic("unreachable") + } + var option2262 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2262 = witTypes.None[uint32]() + case 1: + + option2262 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2263 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2263 = witTypes.None[uint32]() + case 1: + + option2263 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2261, option2262, option2263}) + + case 26: + var option2266 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2266 = witTypes.None[[]string]() + case 1: + result2265 := 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)) + value2264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2265 = append(result2265, value2264) + } + + option2266 = witTypes.Some[[]string](result2265) + default: + panic("unreachable") + } + var option2269 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2269 = witTypes.None[[]string]() + case 1: + result2268 := 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)) + value2267 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2268 = append(result2268, value2267) + } + + option2269 = witTypes.Some[[]string](result2268) + default: + panic("unreachable") + } + + variant2311 = 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)))), option2266, option2269}) + + case 27: + var option2272 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2272 = witTypes.None[[]string]() + case 1: + result2271 := 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)) + value2270 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2271 = append(result2271, value2270) + } + + option2272 = witTypes.Some[[]string](result2271) + default: + panic("unreachable") + } + var option2275 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2275 = witTypes.None[[]string]() + case 1: + result2274 := 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)) + value2273 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2274 = append(result2274, value2273) + } + + option2275 = witTypes.Some[[]string](result2274) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2272, option2275}) + + case 28: + + variant2311 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant2311 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value2276 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2278 := 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)) + value2277 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2278 = append(result2278, value2277) + } + + var option2280 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option2280 = 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))), value2279}) + default: + panic("unreachable") + } + var option2282 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option2282 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option2282 = 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))), value2281}) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2276, result2278, option2280, option2282}) + + case 31: + result2304 := 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)) + value2283 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2292 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value2284 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2292 = golem_core_types.MakeDiscriminatorRulePrefix(value2284) + + case 1: + value2285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2292 = golem_core_types.MakeDiscriminatorRuleSuffix(value2285) + + case 2: + value2286 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2292 = golem_core_types.MakeDiscriminatorRuleContains(value2286) + + case 3: + value2287 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2292 = golem_core_types.MakeDiscriminatorRuleRegex(value2287) + + case 4: + value2288 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option2290 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option2290 = witTypes.None[string]() + case 1: + value2289 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option2290 = witTypes.Some[string](value2289) + default: + panic("unreachable") + } + + variant2292 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2288, option2290}) + + case 5: + value2291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2292 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2291) + + default: + panic("unreachable") + } + var option2294 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option2294 = witTypes.None[string]() + case 1: + value2293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option2294 = witTypes.Some[string](value2293) + default: + panic("unreachable") + } + result2296 := 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)) + 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) + } + + result2298 := 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)) + value2297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2298 = append(result2298, value2297) + } + + var option2300 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option2300 = witTypes.None[string]() + case 1: + value2299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option2300 = witTypes.Some[string](value2299) + default: + panic("unreachable") + } + var option2303 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option2303 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2302 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant2302 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2302 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2302 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2301 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant2302 = golem_core_types.MakeRoleOther(value2301) + + default: + panic("unreachable") + } + + option2303 = witTypes.Some[golem_core_types.Role](variant2302) + default: + panic("unreachable") + } + + result2304 = append(result2304, golem_core_types.UnionBranch{value2283, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2292, golem_core_types.MetadataEnvelope{option2294, result2296, result2298, option2300, option2303}}) + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2304}) + + case 32: + var option2306 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2306 = witTypes.None[string]() + case 1: + value2305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option2306 = witTypes.Some[string](value2305) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2306}) + + case 33: + var option2308 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2308 = witTypes.None[string]() + case 1: + value2307 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option2308 = witTypes.Some[string](value2307) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2308}) + + case 34: + + variant2311 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option2309 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2309 = witTypes.None[int32]() + case 1: + + option2309 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyFutureType(option2309) + + case 36: + var option2310 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2310 = witTypes.None[int32]() + case 1: + + option2310 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2311 = golem_core_types.MakeSchemaTypeBodyStreamType(option2310) + + default: + panic("unreachable") + } + var option2313 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option2313 = witTypes.None[string]() + case 1: + value2312 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option2313 = witTypes.Some[string](value2312) + default: + panic("unreachable") + } + result2315 := 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)) + 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) + } + + result2317 := 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)) + value2316 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2317 = append(result2317, value2316) + } + + var option2319 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option2319 = witTypes.None[string]() + case 1: + value2318 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option2319 = witTypes.Some[string](value2318) + default: + panic("unreachable") + } + var option2322 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option2322 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2321 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant2321 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2321 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2321 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2320 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant2321 = golem_core_types.MakeRoleOther(value2320) + + default: + panic("unreachable") + } + + option2322 = witTypes.Some[golem_core_types.Role](variant2321) + default: + panic("unreachable") + } + + result2323 = append(result2323, golem_core_types.SchemaTypeNode{variant2311, golem_core_types.MetadataEnvelope{option2313, result2315, result2317, option2319, option2322}}) + } + + result2327 := 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)) + value2324 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2326 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2326 = witTypes.None[string]() + case 1: + value2325 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option2326 = witTypes.Some[string](value2325) + default: + panic("unreachable") + } + + result2327 = append(result2327, golem_core_types.SchemaTypeDef{value2324, option2326, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result2351 := 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 variant2350 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2350 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant2350 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant2350 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant2350 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant2350 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant2350 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant2350 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant2350 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant2350 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant2350 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant2350 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant2350 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value2328 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2350 = golem_core_types.MakeSchemaValueNodeStringValue(value2328) + + case 13: + result2329 := 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) + + result2329 = append(result2329, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2350 = golem_core_types.MakeSchemaValueNodeRecordValue(result2329) + + case 14: + var option2330 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2330 = witTypes.None[int32]() + case 1: + + option2330 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2350 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2330}) + + case 15: + + variant2350 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result2331 := 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) + + result2331 = append(result2331, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant2350 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2331) + + case 17: + 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))) + } + + variant2350 = golem_core_types.MakeSchemaValueNodeTupleValue(result2332) + + case 18: + result2333 := 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) + + result2333 = append(result2333, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2350 = golem_core_types.MakeSchemaValueNodeListValue(result2333) + + case 19: + result2334 := 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) + + result2334 = append(result2334, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2350 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2334) + + case 20: + result2335 := 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) + + result2335 = append(result2335, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant2350 = golem_core_types.MakeSchemaValueNodeMapValue(result2335) + + case 21: + var option2336 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2336 = witTypes.None[int32]() + case 1: + + option2336 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2350 = golem_core_types.MakeSchemaValueNodeOptionValue(option2336) + + case 22: + var variant2339 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option2337 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2337 = witTypes.None[int32]() + case 1: + + option2337 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2339 = golem_core_types.MakeResultValuePayloadOkValue(option2337) + + case 1: + var option2338 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2338 = witTypes.None[int32]() + case 1: + + option2338 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2339 = golem_core_types.MakeResultValuePayloadErrValue(option2338) + + default: + panic("unreachable") + } + + variant2350 = golem_core_types.MakeSchemaValueNodeResultValue(variant2339) + + case 23: + value2340 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2342 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2342 = witTypes.None[string]() + case 1: + value2341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2342 = witTypes.Some[string](value2341) + default: + panic("unreachable") + } + + variant2350 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2340, option2342}) + + case 24: + value2343 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2345 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2345 = witTypes.None[string]() + case 1: + value2344 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2345 = witTypes.Some[string](value2344) + default: + panic("unreachable") + } + + variant2350 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2343, option2345}) + + case 25: + value2346 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2350 = golem_core_types.MakeSchemaValueNodePathValue(value2346) + + case 26: + value2347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2350 = golem_core_types.MakeSchemaValueNodeUrlValue(value2347) + + case 27: + + variant2350 = 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: + + variant2350 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value2348 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant2350 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2348}) + + case 30: + value2349 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2350 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2349, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant2350 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant2350 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant2350 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result2351 = append(result2351, variant2350) + } + + value2352 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))) + result2354 := 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)) + value2353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2354 = append(result2354, value2353) + } + + result2366 := 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)) + result2365 := 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 variant2364 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2357 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option2357 = witTypes.None[string]() + case 1: + value2356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option2357 = witTypes.Some[string](value2356) + default: + panic("unreachable") + } + var option2358 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option2358 = witTypes.None[uint64]() + case 1: + + option2358 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result2362 := 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)) + value2359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2361 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value2360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant2361 = golem_api_context.MakeAttributeValueString(value2360) + + default: + panic("unreachable") + } + + result2362 = append(result2362, golem_api_context.Attribute{value2359, variant2361}) + } + + variant2364 = MakeSpanDataLocalSpan(LocalSpanData{value2355, 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))))}, option2357, option2358, result2362, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value2363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2364 = MakeSpanDataExternalSpan(ExternalSpanData{value2363}) + + default: + panic("unreachable") + } + + result2365 = append(result2365, variant2364) + } + + result2366 = append(result2366, result2365) + } + + variant2370 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value2146, value2147, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2323, result2327, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result2351, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value2352, result2354, result2366}) + + case 2: + + variant2370 = MakeAgentInvocationSaveSnapshot() + + case 3: + value2367 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value2368 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + variant2370 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value2367, value2368}}) + + case 4: + value2369 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant2370 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value2369}) + + case 5: + + variant2370 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}) + + default: + panic("unreachable") + } + + variant2694 = 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)))}, variant2370}) + + case 15: + var variant2373 UpdateDescription + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + variant2373 = MakeUpdateDescriptionAutoUpdate() + + case 1: + value2371 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) + value2372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) + + variant2373 = MakeUpdateDescriptionSnapshotBased(golem_api_host.Snapshot{value2371, value2372}) + + default: + panic("unreachable") + } + + variant2694 = 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))), variant2373}) + + case 16: + result2379 := 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)) + value2374 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + value2375 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4)))) + result2378 := 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)) + value2376 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2378 = append(result2378, witTypes.Tuple2[string, string]{value2376, value2377}) + } + + result2379 = append(result2379, 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)), value2374, value2375, result2378}) + } + + variant2694 = 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))), result2379}) + + case 17: + var option2381 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + option2381 = witTypes.None[string]() + case 1: + value2380 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) + + option2381 = witTypes.Some[string](value2380) + default: + panic("unreachable") + } + + variant2694 = 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))), option2381}) + + case 18: + + variant2694 = 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: + + variant2694 = 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: + 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)))) + + variant2694 = 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))), value2382, value2383}) + + case 21: + value2384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value2385 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + variant2694 = 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))), value2384, value2385}) + + case 22: + value2386 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) + value2387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + variant2694 = 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)))), value2386, value2387}) + + case 23: + + variant2694 = 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: + value2388 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + value2389 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))) + result2392 := 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)) + value2390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2391 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2392 = append(result2392, witTypes.Tuple2[string, string]{value2390, value2391}) + } + + variant2694 = 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)), value2388, value2389, result2392}}) + + case 25: + value2393 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + value2394 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))) + result2397 := 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)) + value2395 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2397 = append(result2397, witTypes.Tuple2[string, string]{value2395, value2396}) + } + + variant2694 = 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)), value2393, value2394, result2397}}) + + case 26: + + variant2694 = 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: + value2398 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2694 = 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)))}, value2398}) + + case 28: + value2399 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + var option2401 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option2401 = witTypes.None[string]() + case 1: + value2400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option2401 = witTypes.Some[string](value2400) + default: + panic("unreachable") + } + var option2403 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) { + case 0: + + option2403 = witTypes.None[string]() + case 1: + value2402 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4)))) + + option2403 = witTypes.Some[string](value2402) + default: + panic("unreachable") + } + result2407 := 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)) + value2404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2406 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value2405 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant2406 = golem_api_context.MakeAttributeValueString(value2405) + + default: + panic("unreachable") + } + + result2407 = append(result2407, golem_api_context.Attribute{value2404, variant2406}) + } + + variant2694 = 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)))}, value2399, option2401, option2403, result2407}) + + case 29: + value2408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2694 = 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)))}, value2408}) + + case 30: + value2409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + value2410 := 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 variant2412 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) { + case 0: + value2411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + variant2412 = golem_api_context.MakeAttributeValueString(value2411) + + default: + panic("unreachable") + } + + variant2694 = 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)))}, value2409, value2410, variant2412}) + + case 31: + value2413 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2694 = 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)))}, value2413}) + + case 32: + + variant2694 = 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 33: + + variant2694 = 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 34: + + variant2694 = 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 35: + + variant2694 = 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 36: + value2414 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + value2415 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) + + variant2694 = 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{value2414, value2415}}) + + case 37: + value2416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + value2417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))) + result2420 := 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)) + value2418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2420 = append(result2420, witTypes.Tuple2[string, string]{value2418, value2419}) + } + + value2421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 7*4)))) + + variant2694 = 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)), value2416, value2417, result2420}, 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))))}}, value2421}, 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 38: + value2422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + result2453 := 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 variant2452 golem_api_retry.PredicateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2423 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2425 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2425 = golem_api_retry.MakePredicateValueText(value2424) + + case 1: + + variant2425 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2425 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2452 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2423, variant2425}) + + case 1: + value2426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2428 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2427 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2428 = golem_api_retry.MakePredicateValueText(value2427) + + case 1: + + variant2428 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2428 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2452 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2426, variant2428}) + + case 2: + value2429 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2431 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2430 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2431 = golem_api_retry.MakePredicateValueText(value2430) + + case 1: + + variant2431 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2431 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2452 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2429, variant2431}) + + case 3: + value2432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2434 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2433 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2434 = golem_api_retry.MakePredicateValueText(value2433) + + case 1: + + variant2434 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2434 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2452 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2432, variant2434}) + + case 4: + value2435 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2437 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2436 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2437 = golem_api_retry.MakePredicateValueText(value2436) + + case 1: + + variant2437 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2437 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2452 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2435, variant2437}) + + case 5: + value2438 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2440 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2440 = golem_api_retry.MakePredicateValueText(value2439) + + case 1: + + variant2440 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2440 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2452 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2438, variant2440}) + + case 6: + value2441 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2452 = golem_api_retry.MakePredicateNodePropExists(value2441) + + case 7: + value2442 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2445 := 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 variant2444 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2443 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2444 = golem_api_retry.MakePredicateValueText(value2443) + + case 1: + + variant2444 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 2: + + variant2444 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + default: + panic("unreachable") + } + + result2445 = append(result2445, variant2444) + } + + variant2452 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2442, result2445}) + + case 8: + value2446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2452 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2446, value2447}) + + case 9: + value2448 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2449 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2452 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2448, value2449}) + + case 10: + value2450 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2452 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2450, value2451}) + + case 11: + + variant2452 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2452 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2452 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 14: + + variant2452 = golem_api_retry.MakePredicateNodePredTrue() + + case 15: + + variant2452 = golem_api_retry.MakePredicateNodePredFalse() + + default: + panic("unreachable") + } + + result2453 = append(result2453, variant2452) + } + + result2486 := 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 variant2485 golem_api_retry.PolicyNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2485 = golem_api_retry.MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 1: + + variant2485 = 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: + + variant2485 = 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: + + variant2485 = golem_api_retry.MakePolicyNodeImmediate() + + case 4: + + variant2485 = golem_api_retry.MakePolicyNodeNever() + + case 5: + + variant2485 = 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: + + variant2485 = 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: + + variant2485 = 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: + + variant2485 = 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: + + variant2485 = golem_api_retry.MakePolicyNodeJitter(golem_api_retry.JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))}) + + case 10: + result2484 := 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 variant2483 golem_api_retry.PredicateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2454 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2456 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2455 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2456 = golem_api_retry.MakePredicateValueText(value2455) + + case 1: + + variant2456 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2456 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2483 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2454, variant2456}) + + case 1: + value2457 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2459 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2458 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2459 = golem_api_retry.MakePredicateValueText(value2458) + + case 1: + + variant2459 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2459 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2483 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2457, variant2459}) + + case 2: + value2460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2462 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2461 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2462 = golem_api_retry.MakePredicateValueText(value2461) + + case 1: + + variant2462 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2462 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2483 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2460, variant2462}) + + case 3: + value2463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2465 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2464 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2465 = golem_api_retry.MakePredicateValueText(value2464) + + case 1: + + variant2465 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2465 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2483 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2463, variant2465}) + + case 4: + value2466 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2468 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2468 = golem_api_retry.MakePredicateValueText(value2467) + + case 1: + + variant2468 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2468 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2483 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2466, variant2468}) + + case 5: + value2469 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2471 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2470 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2471 = golem_api_retry.MakePredicateValueText(value2470) + + case 1: + + variant2471 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2471 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2483 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2469, variant2471}) + + case 6: + value2472 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2483 = golem_api_retry.MakePredicateNodePropExists(value2472) + + case 7: + value2473 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2476 := 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 variant2475 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2474 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2475 = golem_api_retry.MakePredicateValueText(value2474) + + case 1: + + variant2475 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 2: + + variant2475 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + default: + panic("unreachable") + } + + result2476 = append(result2476, variant2475) + } + + variant2483 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2473, result2476}) + + case 8: + value2477 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2478 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2483 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2477, value2478}) + + case 9: + value2479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2480 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2483 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2479, value2480}) + + case 10: + value2481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2482 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2483 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2481, value2482}) + + case 11: + + variant2483 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2483 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2483 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 14: + + variant2483 = golem_api_retry.MakePredicateNodePredTrue() + + case 15: + + variant2483 = golem_api_retry.MakePredicateNodePredFalse() + + default: + panic("unreachable") + } + + result2484 = append(result2484, variant2483) + } + + variant2485 = golem_api_retry.MakePolicyNodeFilteredOn(golem_api_retry.FilteredConfig{golem_api_retry.RetryPredicate{result2484}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 11: + + variant2485 = golem_api_retry.MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2485 = golem_api_retry.MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2485 = 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") + } + + result2486 = append(result2486, variant2485) + } + + variant2694 = 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{value2422, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), golem_api_retry.RetryPredicate{result2453}, golem_api_retry.RetryPolicy{result2486}}}) + + case 39: + value2487 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2694 = 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)))}, value2487}) + + case 40: + var variant2488 QueuedCardEvent + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2488 = 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: + + variant2488 = 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") + } + + variant2694 = 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)))}, variant2488}) + + case 41: + var option2489 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + option2489 = witTypes.None[uint64]() + case 1: + + option2489 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + default: + panic("unreachable") + } + + variant2694 = 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)))}, option2489, 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 42: + + variant2694 = 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 43: + + variant2694 = 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 44: + + variant2694 = 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 45: + result2665 := 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 variant2653 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2653 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant2653 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option2496 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2496 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2491 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2491 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2490 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2490 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2490 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2490 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2491 = witTypes.Some[golem_core_types.NumericBound](variant2490) + default: + panic("unreachable") + } + var option2493 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2493 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2492 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2492 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2492 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2492 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2493 = witTypes.Some[golem_core_types.NumericBound](variant2492) + default: + panic("unreachable") + } + var option2495 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2495 = witTypes.None[string]() + case 1: + value2494 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2495 = witTypes.Some[string](value2494) + default: + panic("unreachable") + } + + option2496 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2491, option2493, option2495}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyS8Type(option2496) + + case 3: + var option2503 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2503 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2498 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2498 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2497 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2497 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2497 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2497 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2498 = witTypes.Some[golem_core_types.NumericBound](variant2497) + default: + panic("unreachable") + } + var option2500 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2500 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2499 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2499 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2499 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2499 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2500 = witTypes.Some[golem_core_types.NumericBound](variant2499) + default: + panic("unreachable") + } + var option2502 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2502 = witTypes.None[string]() + case 1: + value2501 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2502 = witTypes.Some[string](value2501) + default: + panic("unreachable") + } + + option2503 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2498, option2500, option2502}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyS16Type(option2503) + + case 4: + var option2510 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2510 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2505 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2505 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2504 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2504 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2504 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2504 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2505 = witTypes.Some[golem_core_types.NumericBound](variant2504) + default: + panic("unreachable") + } + var option2507 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2507 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2506 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2506 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2506 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2506 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2507 = witTypes.Some[golem_core_types.NumericBound](variant2506) + default: + panic("unreachable") + } + var option2509 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2509 = witTypes.None[string]() + case 1: + value2508 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2509 = witTypes.Some[string](value2508) + default: + panic("unreachable") + } + + option2510 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2505, option2507, option2509}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyS32Type(option2510) + + case 5: + var option2517 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2517 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2512 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2512 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2511 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2511 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2511 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2511 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2512 = witTypes.Some[golem_core_types.NumericBound](variant2511) + default: + panic("unreachable") + } + var option2514 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2514 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2513 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2513 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2513 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2513 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2514 = witTypes.Some[golem_core_types.NumericBound](variant2513) + default: + panic("unreachable") + } + var option2516 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2516 = witTypes.None[string]() + case 1: + value2515 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2516 = witTypes.Some[string](value2515) + default: + panic("unreachable") + } + + option2517 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2512, option2514, option2516}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyS64Type(option2517) + + case 6: + var option2524 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2524 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2519 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2519 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2518 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2518 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2518 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2518 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2519 = witTypes.Some[golem_core_types.NumericBound](variant2518) + default: + panic("unreachable") + } + var option2521 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2521 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2520 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2520 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2520 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2520 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2521 = witTypes.Some[golem_core_types.NumericBound](variant2520) + default: + panic("unreachable") + } + var option2523 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2523 = witTypes.None[string]() + case 1: + value2522 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2523 = witTypes.Some[string](value2522) + default: + panic("unreachable") + } + + option2524 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2519, option2521, option2523}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyU8Type(option2524) + + case 7: + var option2531 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2531 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2526 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2526 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2525 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2525 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2525 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2525 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2526 = witTypes.Some[golem_core_types.NumericBound](variant2525) + default: + panic("unreachable") + } + var option2528 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2528 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2527 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2527 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2527 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2527 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2528 = witTypes.Some[golem_core_types.NumericBound](variant2527) + default: + panic("unreachable") + } + var option2530 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2530 = witTypes.None[string]() + case 1: + value2529 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2530 = witTypes.Some[string](value2529) + default: + panic("unreachable") + } + + option2531 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2526, option2528, option2530}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyU16Type(option2531) + + case 8: + var option2538 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2538 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2533 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2533 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2532 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2532 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2532 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2532 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2533 = witTypes.Some[golem_core_types.NumericBound](variant2532) + default: + panic("unreachable") + } + var option2535 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2535 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2534 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2534 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2534 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2534 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2535 = witTypes.Some[golem_core_types.NumericBound](variant2534) + default: + panic("unreachable") + } + var option2537 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2537 = witTypes.None[string]() + case 1: + value2536 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2537 = witTypes.Some[string](value2536) + default: + panic("unreachable") + } + + option2538 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2533, option2535, option2537}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyU32Type(option2538) + + case 9: + var option2545 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2545 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2540 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2540 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2539 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2539 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2539 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2539 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2540 = witTypes.Some[golem_core_types.NumericBound](variant2539) + default: + panic("unreachable") + } + var option2542 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2542 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2541 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2541 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2541 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2541 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2542 = witTypes.Some[golem_core_types.NumericBound](variant2541) + default: + panic("unreachable") + } + var option2544 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2544 = witTypes.None[string]() + case 1: + value2543 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2544 = witTypes.Some[string](value2543) + default: + panic("unreachable") + } + + option2545 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2540, option2542, option2544}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyU64Type(option2545) + + case 10: + var option2552 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2552 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2547 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2547 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2546 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2546 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2546 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2546 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2547 = witTypes.Some[golem_core_types.NumericBound](variant2546) + default: + panic("unreachable") + } + var option2549 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2549 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2548 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2548 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2548 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2548 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2549 = witTypes.Some[golem_core_types.NumericBound](variant2548) + default: + panic("unreachable") + } + var option2551 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2551 = witTypes.None[string]() + case 1: + value2550 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2551 = witTypes.Some[string](value2550) + default: + panic("unreachable") + } + + option2552 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2547, option2549, option2551}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyF32Type(option2552) + + case 11: + var option2559 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2559 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2554 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2554 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2553 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2553 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2553 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2553 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2554 = witTypes.Some[golem_core_types.NumericBound](variant2553) + default: + panic("unreachable") + } + var option2556 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2556 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2555 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2555 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2555 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2555 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2556 = witTypes.Some[golem_core_types.NumericBound](variant2555) + default: + panic("unreachable") + } + var option2558 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2558 = witTypes.None[string]() + case 1: + value2557 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2558 = witTypes.Some[string](value2557) + default: + panic("unreachable") + } + + option2559 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2554, option2556, option2558}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyF64Type(option2559) + + case 12: + + variant2653 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant2653 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result2572 := 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)) + value2560 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2562 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option2562 = witTypes.None[string]() + case 1: + value2561 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option2562 = witTypes.Some[string](value2561) + default: + panic("unreachable") + } + result2564 := 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)) + value2563 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2564 = append(result2564, value2563) + } + + result2566 := 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)) + value2565 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2566 = append(result2566, value2565) + } + + var option2568 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option2568 = witTypes.None[string]() + case 1: + value2567 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option2568 = witTypes.Some[string](value2567) + default: + panic("unreachable") + } + var option2571 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option2571 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2570 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant2570 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2570 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2570 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2569 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant2570 = golem_core_types.MakeRoleOther(value2569) + + default: + panic("unreachable") + } + + option2571 = witTypes.Some[golem_core_types.Role](variant2570) + default: + panic("unreachable") + } + + result2572 = append(result2572, golem_core_types.NamedFieldType{value2560, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2562, result2564, result2566, option2568, option2571}}) + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyRecordType(result2572) + + case 15: + result2586 := 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)) + value2573 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2574 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2574 = witTypes.None[int32]() + case 1: + + option2574 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option2576 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2576 = witTypes.None[string]() + case 1: + value2575 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2576 = witTypes.Some[string](value2575) + default: + panic("unreachable") + } + result2578 := 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)) + value2577 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2578 = append(result2578, value2577) + } + + result2580 := 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)) + value2579 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2580 = append(result2580, value2579) + } + + var option2582 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option2582 = witTypes.None[string]() + case 1: + value2581 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option2582 = witTypes.Some[string](value2581) + default: + panic("unreachable") + } + var option2585 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option2585 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2584 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant2584 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2584 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2584 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2583 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant2584 = golem_core_types.MakeRoleOther(value2583) + + default: + panic("unreachable") + } + + option2585 = witTypes.Some[golem_core_types.Role](variant2584) + default: + panic("unreachable") + } + + result2586 = append(result2586, golem_core_types.VariantCaseType{value2573, option2574, golem_core_types.MetadataEnvelope{option2576, result2578, result2580, option2582, option2585}}) + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyVariantType(result2586) + + case 16: + result2588 := 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)) + value2587 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2588 = append(result2588, value2587) + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyEnumType(result2588) + + case 17: + result2590 := 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)) + value2589 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2590 = append(result2590, value2589) + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2590) + + case 18: + result2591 := 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) + + result2591 = append(result2591, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyTupleType(result2591) + + case 19: + + variant2653 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant2653 = 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: + + variant2653 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant2653 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option2592 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2592 = witTypes.None[int32]() + case 1: + + option2592 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option2593 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2593 = witTypes.None[int32]() + case 1: + + option2593 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2592, option2593}) + + case 24: + var option2596 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2596 = witTypes.None[[]string]() + case 1: + result2595 := 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)) + value2594 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2595 = append(result2595, value2594) + } + + option2596 = witTypes.Some[[]string](result2595) + default: + panic("unreachable") + } + var option2597 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2597 = witTypes.None[uint32]() + case 1: + + option2597 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2598 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2598 = witTypes.None[uint32]() + case 1: + + option2598 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option2600 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option2600 = witTypes.None[string]() + case 1: + value2599 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option2600 = witTypes.Some[string](value2599) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2596, option2597, option2598, option2600}) + + case 25: + var option2603 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2603 = witTypes.None[[]string]() + case 1: + result2602 := 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)) + value2601 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2602 = append(result2602, value2601) + } + + option2603 = witTypes.Some[[]string](result2602) + default: + panic("unreachable") + } + var option2604 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2604 = witTypes.None[uint32]() + case 1: + + option2604 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2605 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2605 = witTypes.None[uint32]() + case 1: + + option2605 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2603, option2604, option2605}) + + case 26: + var option2608 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2608 = witTypes.None[[]string]() + case 1: + result2607 := 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)) + value2606 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2607 = append(result2607, value2606) + } + + option2608 = witTypes.Some[[]string](result2607) + default: + panic("unreachable") + } + var option2611 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2611 = witTypes.None[[]string]() + case 1: + result2610 := 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)) + value2609 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2610 = append(result2610, value2609) + } + + option2611 = witTypes.Some[[]string](result2610) + default: + panic("unreachable") + } + + variant2653 = 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)))), option2608, option2611}) + + case 27: + var option2614 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2614 = witTypes.None[[]string]() + case 1: + result2613 := 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)) + value2612 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2613 = append(result2613, value2612) + } + + option2614 = witTypes.Some[[]string](result2613) + default: + panic("unreachable") + } + var option2617 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2617 = witTypes.None[[]string]() + case 1: + result2616 := 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)) + value2615 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2616 = append(result2616, value2615) + } + + option2617 = witTypes.Some[[]string](result2616) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2614, option2617}) + + case 28: + + variant2653 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant2653 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value2618 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2620 := 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)) + value2619 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2620 = append(result2620, value2619) + } + + var option2622 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2622 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2621 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option2622 = 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))), value2621}) + default: + panic("unreachable") + } + var option2624 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option2624 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2623 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option2624 = 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))), value2623}) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2618, result2620, option2622, option2624}) + + case 31: + result2646 := 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)) + value2625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2634 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value2626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2634 = golem_core_types.MakeDiscriminatorRulePrefix(value2626) + + case 1: + value2627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2634 = golem_core_types.MakeDiscriminatorRuleSuffix(value2627) + + case 2: + value2628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2634 = golem_core_types.MakeDiscriminatorRuleContains(value2628) + + case 3: + value2629 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2634 = golem_core_types.MakeDiscriminatorRuleRegex(value2629) + + case 4: + value2630 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option2632 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option2632 = witTypes.None[string]() + case 1: + value2631 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option2632 = witTypes.Some[string](value2631) + default: + panic("unreachable") + } + + variant2634 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2630, option2632}) + + case 5: + value2633 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2634 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2633) + + default: + panic("unreachable") + } + var option2636 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option2636 = witTypes.None[string]() + case 1: + value2635 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option2636 = witTypes.Some[string](value2635) + default: + panic("unreachable") + } + result2638 := 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)) + value2637 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2638 = append(result2638, value2637) + } + + result2640 := 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)) + value2639 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2640 = append(result2640, value2639) + } + + var option2642 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option2642 = witTypes.None[string]() + case 1: + value2641 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option2642 = witTypes.Some[string](value2641) + default: + panic("unreachable") + } + var option2645 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option2645 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2644 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant2644 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2644 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2644 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2643 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant2644 = golem_core_types.MakeRoleOther(value2643) + + default: + panic("unreachable") + } + + option2645 = witTypes.Some[golem_core_types.Role](variant2644) + default: + panic("unreachable") + } + + result2646 = append(result2646, golem_core_types.UnionBranch{value2625, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2634, golem_core_types.MetadataEnvelope{option2636, result2638, result2640, option2642, option2645}}) + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2646}) + + case 32: + var option2648 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2648 = witTypes.None[string]() + case 1: + value2647 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option2648 = witTypes.Some[string](value2647) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2648}) + + case 33: + var option2650 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2650 = witTypes.None[string]() + case 1: + value2649 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option2650 = witTypes.Some[string](value2649) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2650}) + + case 34: + + variant2653 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyFutureType(option2651) + + case 36: + var option2652 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2652 = witTypes.None[int32]() + case 1: + + option2652 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2653 = golem_core_types.MakeSchemaTypeBodyStreamType(option2652) + + default: + panic("unreachable") + } + var option2655 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option2655 = witTypes.None[string]() + case 1: + value2654 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option2655 = witTypes.Some[string](value2654) + default: + panic("unreachable") + } + result2657 := 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)) + value2656 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2657 = append(result2657, value2656) + } + + result2659 := 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)) + value2658 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2659 = append(result2659, value2658) + } + + var option2661 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option2661 = witTypes.None[string]() + case 1: + value2660 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option2661 = witTypes.Some[string](value2660) + default: + panic("unreachable") + } + var option2664 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option2664 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2663 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant2663 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2663 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2663 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2662 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant2663 = golem_core_types.MakeRoleOther(value2662) + + default: + panic("unreachable") + } + + option2664 = witTypes.Some[golem_core_types.Role](variant2663) + default: + panic("unreachable") + } + + result2665 = append(result2665, golem_core_types.SchemaTypeNode{variant2653, golem_core_types.MetadataEnvelope{option2655, result2657, result2659, option2661, option2664}}) + } + + result2669 := 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)) + value2666 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2668 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2668 = witTypes.None[string]() + case 1: + value2667 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option2668 = witTypes.Some[string](value2667) + default: + panic("unreachable") + } + + result2669 = append(result2669, golem_core_types.SchemaTypeDef{value2666, option2668, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result2693 := 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 variant2692 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2692 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant2692 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant2692 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant2692 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant2692 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant2692 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant2692 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant2692 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant2692 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant2692 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant2692 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant2692 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value2670 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2692 = golem_core_types.MakeSchemaValueNodeStringValue(value2670) + + case 13: + result2671 := 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) + + result2671 = append(result2671, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2692 = golem_core_types.MakeSchemaValueNodeRecordValue(result2671) + + case 14: + var option2672 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2672 = witTypes.None[int32]() + case 1: + + option2672 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2692 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2672}) + + case 15: + + variant2692 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result2673 := 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) + + result2673 = append(result2673, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant2692 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2673) + + case 17: + 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))) + } + + variant2692 = golem_core_types.MakeSchemaValueNodeTupleValue(result2674) + + case 18: + 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))) + } + + variant2692 = golem_core_types.MakeSchemaValueNodeListValue(result2675) + + case 19: + result2676 := 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) + + result2676 = append(result2676, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2692 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2676) + + case 20: + result2677 := 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) + + result2677 = append(result2677, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant2692 = golem_core_types.MakeSchemaValueNodeMapValue(result2677) + + case 21: + var option2678 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2678 = witTypes.None[int32]() + case 1: + + option2678 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2692 = golem_core_types.MakeSchemaValueNodeOptionValue(option2678) + + case 22: + var variant2681 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant2681 = golem_core_types.MakeResultValuePayloadOkValue(option2679) + + case 1: + var option2680 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2680 = witTypes.None[int32]() + case 1: + + option2680 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2681 = golem_core_types.MakeResultValuePayloadErrValue(option2680) + + default: + panic("unreachable") + } + + variant2692 = golem_core_types.MakeSchemaValueNodeResultValue(variant2681) + + case 23: + value2682 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2684 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2684 = witTypes.None[string]() + case 1: + value2683 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2684 = witTypes.Some[string](value2683) + default: + panic("unreachable") + } + + variant2692 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2682, option2684}) + + case 24: + value2685 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2687 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2687 = witTypes.None[string]() + case 1: + value2686 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2687 = witTypes.Some[string](value2686) + default: + panic("unreachable") + } + + variant2692 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2685, option2687}) + + case 25: + value2688 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2692 = golem_core_types.MakeSchemaValueNodePathValue(value2688) + + case 26: + value2689 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2692 = golem_core_types.MakeSchemaValueNodeUrlValue(value2689) + + case 27: + + variant2692 = 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: + + variant2692 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value2690 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant2692 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2690}) + + case 30: + value2691 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2692 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2691, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant2692 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant2692 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant2692 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result2693 = append(result2693, variant2692) + } + + variant2694 = 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{result2665, result2669, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result2693, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}}) + + case 46: + + variant2694 = 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)))}) + + case 47: + + variant2694 = MakePublicOplogEntryCompletionDelivered(CompletionDeliveredParameters{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") + } + + result2695 = append(result2695, variant2694) + } + + result2697 = witTypes.Ok[[]PublicOplogEntry, string](result2695) + case 1: + value2696 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))) + + result2697 = witTypes.Err[[]PublicOplogEntry, string](value2696) + default: + panic("unreachable") + } + result2698 := result2697 + return result2698 + +} + +//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.Result[witTypes.Option[[]PublicOplogEntry], OplogReadError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4)) + wasm_import_method_get_oplog_get_next((self).Handle(), returnArea) + var result2477 witTypes.Result[witTypes.Option[[]PublicOplogEntry], OplogReadError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + var option2474 witTypes.Option[[]PublicOplogEntry] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + option2474 = witTypes.None[[]PublicOplogEntry]() + case 1: + result2473 := make([]PublicOplogEntry, 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*(168+10*4)) + var variant2472 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: + + variant173 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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)))))) + + case 33: + + variant212 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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") + } + + variant2472 = 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 option218 witTypes.Option[golem_core_types.Uuid] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) { + case 0: + + option218 = witTypes.None[golem_core_types.Uuid]() + case 1: + + option218 = witTypes.Some[golem_core_types.Uuid](golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4))))}) + default: + panic("unreachable") + } + var option219 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) { + case 0: + + option219 = witTypes.None[uint64]() + case 1: + + option219 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4))))) + default: + panic("unreachable") + } + var option424 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 2*4)))) { + case 0: + + option424 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result395 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 4*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 3*4))))), index*(56+22*4)) + var variant383 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant383 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant383 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS8Type(option226) + + case 3: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS16Type(option233) + + case 4: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS32Type(option240) + + case 5: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS64Type(option247) + + case 6: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU8Type(option254) + + case 7: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU16Type(option261) + + case 8: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU32Type(option268) + + case 9: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU64Type(option275) + + case 10: + var option282 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option282 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option277 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant276 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant276 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant276 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option277 = witTypes.Some[golem_core_types.NumericBound](variant276) + default: + panic("unreachable") + } + var option279 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option279 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant278 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant278 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant278 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant278 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option279 = witTypes.Some[golem_core_types.NumericBound](variant278) + default: + panic("unreachable") + } + var option281 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option281 = witTypes.None[string]() + case 1: + value280 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option281 = witTypes.Some[string](value280) + default: + panic("unreachable") + } + + option282 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option277, option279, option281}) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyF32Type(option282) + + case 11: + var option289 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option289 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option284 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option284 = witTypes.Some[golem_core_types.NumericBound](variant283) + default: + panic("unreachable") + } + var option286 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option286 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant285 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant285 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant285 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant285 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option286 = witTypes.Some[golem_core_types.NumericBound](variant285) + default: + panic("unreachable") + } + var option288 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option288 = witTypes.None[string]() + case 1: + value287 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option288 = witTypes.Some[string](value287) + default: + panic("unreachable") + } + + option289 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option284, option286, option288}) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyF64Type(option289) + + case 12: + + variant383 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant383 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result302 := 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)) + value290 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option292 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option292 = witTypes.None[string]() + case 1: + value291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option292 = witTypes.Some[string](value291) + default: + panic("unreachable") + } + result294 := 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)) + 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), (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)) + 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), (10 * 4)))) { + case 0: + + option298 = witTypes.None[string]() + case 1: + value297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 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), (13 * 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), (14 * 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), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 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.NamedFieldType{value290, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option292, result294, result296, option298, option301}}) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyRecordType(result302) + + case 15: + result316 := 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)) + value303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option304 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option304 = witTypes.None[int32]() + case 1: + + option304 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option306 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option306 = witTypes.None[string]() + case 1: + value305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option306 = witTypes.Some[string](value305) + default: + panic("unreachable") + } + result308 := 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)) + 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) + } + + result310 := 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)) + value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result310 = append(result310, value309) + } + + var option312 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option312 = witTypes.None[string]() + case 1: + value311 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option312 = witTypes.Some[string](value311) + default: + panic("unreachable") + } + var option315 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option315 = witTypes.None[golem_core_types.Role]() + case 1: + var variant314 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant314 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant314 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant314 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant314 = golem_core_types.MakeRoleOther(value313) + + default: + panic("unreachable") + } + + option315 = witTypes.Some[golem_core_types.Role](variant314) + default: + panic("unreachable") + } + + result316 = append(result316, golem_core_types.VariantCaseType{value303, option304, golem_core_types.MetadataEnvelope{option306, result308, result310, option312, option315}}) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyVariantType(result316) + + case 16: + 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) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyEnumType(result318) + + case 17: + result320 := 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)) + 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) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyFlagsType(result320) + + case 18: + result321 := 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) + + result321 = append(result321, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyTupleType(result321) + + case 19: + + variant383 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant383 = 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: + + variant383 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant383 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option322 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option322 = witTypes.None[int32]() + case 1: + + option322 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option323 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option323 = witTypes.None[int32]() + case 1: + + option323 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option322, option323}) + + case 24: + var option326 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option326 = witTypes.None[[]string]() + case 1: + result325 := 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)) + value324 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result325 = append(result325, value324) + } + + option326 = witTypes.Some[[]string](result325) + default: + panic("unreachable") + } + var option327 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option327 = witTypes.None[uint32]() + case 1: + + option327 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option328 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option328 = witTypes.None[uint32]() + case 1: + + option328 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option330 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option330 = witTypes.None[string]() + case 1: + value329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option330 = witTypes.Some[string](value329) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option326, option327, option328, option330}) + + case 25: + var option333 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option333 = witTypes.None[[]string]() + case 1: + result332 := 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)) + 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") + } + var option334 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option334 = witTypes.None[uint32]() + case 1: + + option334 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option335 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option335 = witTypes.None[uint32]() + case 1: + + option335 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option333, option334, option335}) + + case 26: + var option338 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option338 = witTypes.None[[]string]() + case 1: + result337 := 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)) + 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 option341 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option341 = witTypes.None[[]string]() + case 1: + result340 := 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)) + 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) + } + + option341 = witTypes.Some[[]string](result340) + default: + panic("unreachable") + } + + variant383 = 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)))), option338, option341}) + + case 27: + var option344 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option344 = witTypes.None[[]string]() + case 1: + result343 := 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)) + value342 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result343 = append(result343, value342) + } + + option344 = witTypes.Some[[]string](result343) + default: + panic("unreachable") + } + var option347 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option347 = witTypes.None[[]string]() + case 1: + result346 := 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)) + value345 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result346 = append(result346, value345) + } + + option347 = witTypes.Some[[]string](result346) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option344, option347}) + + case 28: + + variant383 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant383 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value348 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result350 := 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)) + value349 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result350 = append(result350, value349) + } + + var option352 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option352 = 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))), value351}) + default: + panic("unreachable") + } + var option354 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option354 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option354 = 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))), value353}) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value348, result350, option352, option354}) + + case 31: + result376 := 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)) + value355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant364 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRulePrefix(value356) + + case 1: + value357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleSuffix(value357) + + case 2: + value358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleContains(value358) + + case 3: + value359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleRegex(value359) + + case 4: + value360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option362 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option362 = witTypes.None[string]() + case 1: + value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option362 = witTypes.Some[string](value361) + default: + panic("unreachable") + } + + variant364 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value360, option362}) + + case 5: + value363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value363) + + default: + panic("unreachable") + } + var option366 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option366 = witTypes.None[string]() + case 1: + value365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option366 = witTypes.Some[string](value365) + default: + panic("unreachable") + } + result368 := 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)) + 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) + } + + result370 := 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)) + value369 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result370 = append(result370, value369) + } + + var option372 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option372 = witTypes.None[string]() + case 1: + value371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option372 = witTypes.Some[string](value371) + default: + panic("unreachable") + } + var option375 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option375 = witTypes.None[golem_core_types.Role]() + case 1: + var variant374 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant374 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant374 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant374 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant374 = golem_core_types.MakeRoleOther(value373) + + default: + panic("unreachable") + } + + option375 = witTypes.Some[golem_core_types.Role](variant374) + default: + panic("unreachable") + } + + result376 = append(result376, golem_core_types.UnionBranch{value355, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant364, golem_core_types.MetadataEnvelope{option366, result368, result370, option372, option375}}) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result376}) + + case 32: + var option378 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option378 = witTypes.None[string]() + case 1: + value377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option378 = witTypes.Some[string](value377) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option378}) + + case 33: + var option380 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option380 = witTypes.None[string]() + case 1: + value379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option380 = witTypes.Some[string](value379) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option380}) + + case 34: + + variant383 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option381 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option381 = witTypes.None[int32]() + case 1: + + option381 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyFutureType(option381) + + case 36: + var option382 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option382 = witTypes.None[int32]() + case 1: + + option382 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyStreamType(option382) + + default: + panic("unreachable") + } + var option385 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option385 = witTypes.None[string]() + case 1: + value384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option385 = witTypes.Some[string](value384) + default: + panic("unreachable") + } + result387 := 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)) + 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) + } + + result389 := 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)) + value388 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result389 = append(result389, value388) + } + + var option391 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option391 = witTypes.None[string]() + case 1: + value390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option391 = witTypes.Some[string](value390) + default: + panic("unreachable") + } + var option394 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option394 = witTypes.None[golem_core_types.Role]() + case 1: + var variant393 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant393 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant393 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant393 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant393 = golem_core_types.MakeRoleOther(value392) + + default: + panic("unreachable") + } + + option394 = witTypes.Some[golem_core_types.Role](variant393) + default: + panic("unreachable") + } + + result395 = append(result395, golem_core_types.SchemaTypeNode{variant383, golem_core_types.MetadataEnvelope{option385, result387, result389, option391, option394}}) + } + + result399 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 6*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 6*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 5*4))))), index*(6*4)) + value396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option398 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option398 = witTypes.None[string]() + case 1: + value397 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option398 = witTypes.Some[string](value397) + default: + panic("unreachable") + } + + result399 = append(result399, golem_core_types.SchemaTypeDef{value396, option398, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result423 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 9*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 9*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (80 + 8*4))))), index*(16+4*4)) + var variant422 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant422 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant422 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant422 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant422 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant422 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant422 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant422 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant422 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant422 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant422 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant422 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant422 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeStringValue(value400) + + case 13: + result401 := 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) + + result401 = append(result401, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeRecordValue(result401) + + case 14: + var option402 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option402 = witTypes.None[int32]() + case 1: + + option402 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option402}) + + case 15: + + variant422 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result403 := 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) + + result403 = append(result403, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant422 = golem_core_types.MakeSchemaValueNodeFlagsValue(result403) + + case 17: + 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))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeTupleValue(result404) + + case 18: + result405 := 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) + + result405 = append(result405, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeListValue(result405) + + case 19: + result406 := 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) + + result406 = append(result406, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeFixedListValue(result406) + + case 20: + result407 := 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) + + result407 = append(result407, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant422 = golem_core_types.MakeSchemaValueNodeMapValue(result407) + + case 21: + var option408 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option408 = witTypes.None[int32]() + case 1: + + option408 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeOptionValue(option408) + + case 22: + var variant411 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option409 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option409 = witTypes.None[int32]() + case 1: + + option409 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant411 = golem_core_types.MakeResultValuePayloadOkValue(option409) + + case 1: + var option410 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option410 = witTypes.None[int32]() + case 1: + + option410 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant411 = golem_core_types.MakeResultValuePayloadErrValue(option410) + + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeResultValue(variant411) + + case 23: + value412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option414 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option414 = witTypes.None[string]() + case 1: + value413 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option414 = witTypes.Some[string](value413) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value412, option414}) + + case 24: + value415 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option417 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option417 = witTypes.None[string]() + case 1: + value416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option417 = witTypes.Some[string](value416) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value415, option417}) + + case 25: + value418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodePathValue(value418) + + case 26: + value419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeUrlValue(value419) + + case 27: + + variant422 = 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: + + variant422 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value420}) + + case 30: + value421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value421, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant422 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant422 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant422 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result423 = append(result423, variant422) + } + + option424 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result395, result399, *(*int32)(unsafe.Add(unsafe.Pointer(base), (80 + 7*4)))}, golem_core_types.SchemaValueTree{result423, *(*int32)(unsafe.Add(unsafe.Pointer(base), (80 + 10*4)))}}) + default: + panic("unreachable") + } + var variant427 WrappedFunctionType + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 10*4)))) { + case 0: + + variant427 = MakeWrappedFunctionTypeReadLocal() + + case 1: + + variant427 = MakeWrappedFunctionTypeWriteLocal() + + case 2: + + variant427 = MakeWrappedFunctionTypeReadRemote() + + case 3: + + variant427 = MakeWrappedFunctionTypeWriteRemote() + + case 4: + var option425 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (96 + 10*4)))) { + case 0: + + option425 = witTypes.None[uint64]() + case 1: + + option425 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 10*4))))) + default: + panic("unreachable") + } + + variant427 = MakeWrappedFunctionTypeWriteRemoteBatched(option425) + + case 5: + var option426 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (96 + 10*4)))) { + case 0: + + option426 = witTypes.None[uint64]() + case 1: + + option426 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (104 + 10*4))))) + default: + panic("unreachable") + } + + variant427 = MakeWrappedFunctionTypeWriteRemoteTransaction(option426) + + default: + panic("unreachable") + } + + variant2472 = 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, option218, option219, option424, variant427}) + + case 2: + var option632 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + option632 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result603 := 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 variant591 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant591 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant591 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option434 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option434 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option429 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant428 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant428 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant428 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option429 = witTypes.Some[golem_core_types.NumericBound](variant428) + default: + panic("unreachable") + } + var option431 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option431 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant430 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant430 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant430 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant430 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option431 = witTypes.Some[golem_core_types.NumericBound](variant430) + default: + panic("unreachable") + } + var option433 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option433 = witTypes.None[string]() + case 1: + value432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option433 = witTypes.Some[string](value432) + default: + panic("unreachable") + } + + option434 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option429, option431, option433}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS8Type(option434) + + case 3: + var option441 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option441 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option436 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant435 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant435 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant435 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option436 = witTypes.Some[golem_core_types.NumericBound](variant435) + default: + panic("unreachable") + } + var option438 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option438 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant437 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant437 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant437 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant437 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option438 = witTypes.Some[golem_core_types.NumericBound](variant437) + default: + panic("unreachable") + } + var option440 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option440 = witTypes.None[string]() + case 1: + value439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option440 = witTypes.Some[string](value439) + default: + panic("unreachable") + } + + option441 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option436, option438, option440}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS16Type(option441) + + case 4: + var option448 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option448 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option443 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant442 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant442 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant442 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option443 = witTypes.Some[golem_core_types.NumericBound](variant442) + default: + panic("unreachable") + } + var option445 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option445 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant444 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant444 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant444 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant444 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option445 = witTypes.Some[golem_core_types.NumericBound](variant444) + default: + panic("unreachable") + } + var option447 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option447 = witTypes.None[string]() + case 1: + value446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option447 = witTypes.Some[string](value446) + default: + panic("unreachable") + } + + option448 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option443, option445, option447}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS32Type(option448) + + case 5: + var option455 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option455 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option450 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant449 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant449 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant449 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option450 = witTypes.Some[golem_core_types.NumericBound](variant449) + default: + panic("unreachable") + } + var option452 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option452 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant451 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant451 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant451 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant451 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option452 = witTypes.Some[golem_core_types.NumericBound](variant451) + default: + panic("unreachable") + } + var option454 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option454 = witTypes.None[string]() + case 1: + value453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option454 = witTypes.Some[string](value453) + default: + panic("unreachable") + } + + option455 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option450, option452, option454}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS64Type(option455) + + case 6: + var option462 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option462 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option457 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant456 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant456 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant456 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option457 = witTypes.Some[golem_core_types.NumericBound](variant456) + default: + panic("unreachable") + } + var option459 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option459 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant458 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant458 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant458 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant458 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option459 = witTypes.Some[golem_core_types.NumericBound](variant458) + default: + panic("unreachable") + } + var option461 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option461 = witTypes.None[string]() + case 1: + value460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option461 = witTypes.Some[string](value460) + default: + panic("unreachable") + } + + option462 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option457, option459, option461}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU8Type(option462) + + case 7: + var option469 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option469 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option464 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant463 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant463 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant463 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option464 = witTypes.Some[golem_core_types.NumericBound](variant463) + default: + panic("unreachable") + } + var option466 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option466 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant465 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant465 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant465 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant465 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option466 = witTypes.Some[golem_core_types.NumericBound](variant465) + default: + panic("unreachable") + } + var option468 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option468 = witTypes.None[string]() + case 1: + value467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option468 = witTypes.Some[string](value467) + default: + panic("unreachable") + } + + option469 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option464, option466, option468}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU16Type(option469) + + case 8: + var option476 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option476 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option471 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant470 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant470 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant470 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option471 = witTypes.Some[golem_core_types.NumericBound](variant470) + default: + panic("unreachable") + } + var option473 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option473 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant472 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant472 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant472 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant472 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option473 = witTypes.Some[golem_core_types.NumericBound](variant472) + default: + panic("unreachable") + } + var option475 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option475 = witTypes.None[string]() + case 1: + value474 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option475 = witTypes.Some[string](value474) + default: + panic("unreachable") + } + + option476 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option471, option473, option475}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU32Type(option476) + + case 9: + var option483 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option483 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option478 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant477 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant477 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant477 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option478 = witTypes.Some[golem_core_types.NumericBound](variant477) + default: + panic("unreachable") + } + var option480 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option480 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant479 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant479 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant479 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant479 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option480 = witTypes.Some[golem_core_types.NumericBound](variant479) + default: + panic("unreachable") + } + var option482 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option482 = witTypes.None[string]() + case 1: + value481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option482 = witTypes.Some[string](value481) + default: + panic("unreachable") + } + + option483 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option478, option480, option482}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU64Type(option483) + + case 10: + var option490 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option490 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option485 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant484 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant484 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant484 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option485 = witTypes.Some[golem_core_types.NumericBound](variant484) + default: + panic("unreachable") + } + var option487 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option487 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant486 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant486 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant486 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant486 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option487 = witTypes.Some[golem_core_types.NumericBound](variant486) + default: + panic("unreachable") + } + var option489 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option489 = witTypes.None[string]() + case 1: + value488 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option489 = witTypes.Some[string](value488) + default: + panic("unreachable") + } + + option490 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option485, option487, option489}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyF32Type(option490) + + case 11: + var option497 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option497 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option492 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant491 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant491 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant491 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option492 = witTypes.Some[golem_core_types.NumericBound](variant491) + default: + panic("unreachable") + } + var option494 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option494 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant493 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant493 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant493 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant493 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option494 = witTypes.Some[golem_core_types.NumericBound](variant493) + default: + panic("unreachable") + } + var option496 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option496 = witTypes.None[string]() + case 1: + value495 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option496 = witTypes.Some[string](value495) + default: + panic("unreachable") + } + + option497 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option492, option494, option496}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyF64Type(option497) + + case 12: + + variant591 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant591 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result510 := 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)) + value498 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option500 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option500 = witTypes.None[string]() + case 1: + value499 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option500 = witTypes.Some[string](value499) + default: + panic("unreachable") + } + result502 := 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)) + 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) + } + + result504 := 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)) + value503 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result504 = append(result504, value503) + } + + var option506 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option506 = witTypes.None[string]() + case 1: + value505 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option506 = witTypes.Some[string](value505) + default: + panic("unreachable") + } + var option509 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option509 = witTypes.None[golem_core_types.Role]() + case 1: + var variant508 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant508 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant508 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant508 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value507 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant508 = golem_core_types.MakeRoleOther(value507) + + default: + panic("unreachable") + } + + option509 = witTypes.Some[golem_core_types.Role](variant508) + default: + panic("unreachable") + } + + result510 = append(result510, golem_core_types.NamedFieldType{value498, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option500, result502, result504, option506, option509}}) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyRecordType(result510) + + case 15: + result524 := 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)) + value511 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option512 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option512 = witTypes.None[int32]() + case 1: + + option512 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option514 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option514 = witTypes.None[string]() + case 1: + value513 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option514 = witTypes.Some[string](value513) + default: + panic("unreachable") + } + result516 := 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)) + 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) + } + + result518 := 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)) + value517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result518 = append(result518, value517) + } + + var option520 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option520 = witTypes.None[string]() + case 1: + value519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option520 = witTypes.Some[string](value519) + default: + panic("unreachable") + } + var option523 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option523 = witTypes.None[golem_core_types.Role]() + case 1: + var variant522 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant522 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant522 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant522 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value521 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant522 = golem_core_types.MakeRoleOther(value521) + + default: + panic("unreachable") + } + + option523 = witTypes.Some[golem_core_types.Role](variant522) + default: + panic("unreachable") + } + + result524 = append(result524, golem_core_types.VariantCaseType{value511, option512, golem_core_types.MetadataEnvelope{option514, result516, result518, option520, option523}}) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyVariantType(result524) + + case 16: + 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) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyEnumType(result526) + + case 17: + result528 := 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)) + 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) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyFlagsType(result528) + + case 18: + result529 := 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) + + result529 = append(result529, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyTupleType(result529) + + case 19: + + variant591 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant591 = 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: + + variant591 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant591 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option530 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option530 = witTypes.None[int32]() + case 1: + + option530 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option531 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option531 = witTypes.None[int32]() + case 1: + + option531 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option530, option531}) + + case 24: + var option534 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option534 = witTypes.None[[]string]() + case 1: + result533 := 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)) + value532 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result533 = append(result533, value532) + } + + option534 = witTypes.Some[[]string](result533) + default: + panic("unreachable") + } + var option535 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option535 = witTypes.None[uint32]() + case 1: + + option535 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option536 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option536 = witTypes.None[uint32]() + case 1: + + option536 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option538 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option538 = witTypes.None[string]() + case 1: + value537 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option538 = witTypes.Some[string](value537) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option534, option535, option536, option538}) + + case 25: + var option541 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option541 = witTypes.None[[]string]() + case 1: + result540 := 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)) + 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) + } + + option541 = witTypes.Some[[]string](result540) + default: + panic("unreachable") + } + var option542 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option542 = witTypes.None[uint32]() + case 1: + + option542 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option543 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option543 = witTypes.None[uint32]() + case 1: + + option543 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option541, option542, option543}) + + case 26: + var option546 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option546 = witTypes.None[[]string]() + case 1: + result545 := 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)) + 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 option549 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option549 = witTypes.None[[]string]() + case 1: + result548 := 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)) + value547 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result548 = append(result548, value547) + } + + option549 = witTypes.Some[[]string](result548) + default: + panic("unreachable") + } + + variant591 = 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)))), option546, option549}) + + case 27: + var option552 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option552 = witTypes.None[[]string]() + case 1: + result551 := 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)) + value550 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result551 = append(result551, value550) + } + + option552 = witTypes.Some[[]string](result551) + default: + panic("unreachable") + } + var option555 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option555 = witTypes.None[[]string]() + case 1: + result554 := 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)) + value553 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result554 = append(result554, value553) + } + + option555 = witTypes.Some[[]string](result554) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option552, option555}) + + case 28: + + variant591 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant591 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value556 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result558 := 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)) + value557 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result558 = append(result558, value557) + } + + var option560 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option560 = 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))), value559}) + default: + panic("unreachable") + } + var option562 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option562 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value561 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option562 = 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))), value561}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value556, result558, option560, option562}) + + case 31: + result584 := 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)) + value563 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant572 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRulePrefix(value564) + + case 1: + value565 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleSuffix(value565) + + case 2: + value566 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleContains(value566) + + case 3: + value567 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleRegex(value567) + + case 4: + value568 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option570 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option570 = witTypes.None[string]() + case 1: + value569 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option570 = witTypes.Some[string](value569) + default: + panic("unreachable") + } + + variant572 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value568, option570}) + + case 5: + value571 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value571) + + default: + panic("unreachable") + } + var option574 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option574 = witTypes.None[string]() + case 1: + value573 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option574 = witTypes.Some[string](value573) + default: + panic("unreachable") + } + result576 := 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)) + 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) + } + + result578 := 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)) + value577 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result578 = append(result578, value577) + } + + var option580 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option580 = witTypes.None[string]() + case 1: + value579 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option580 = witTypes.Some[string](value579) + default: + panic("unreachable") + } + var option583 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option583 = witTypes.None[golem_core_types.Role]() + case 1: + var variant582 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant582 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant582 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant582 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value581 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant582 = golem_core_types.MakeRoleOther(value581) + + default: + panic("unreachable") + } + + option583 = witTypes.Some[golem_core_types.Role](variant582) + default: + panic("unreachable") + } + + result584 = append(result584, golem_core_types.UnionBranch{value563, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant572, golem_core_types.MetadataEnvelope{option574, result576, result578, option580, option583}}) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result584}) + + case 32: + var option586 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option586 = witTypes.None[string]() + case 1: + value585 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option586 = witTypes.Some[string](value585) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option586}) + + case 33: + var option588 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option588 = witTypes.None[string]() + case 1: + value587 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option588 = witTypes.Some[string](value587) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option588}) + + case 34: + + variant591 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option589 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option589 = witTypes.None[int32]() + case 1: + + option589 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyFutureType(option589) + + case 36: + var option590 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option590 = witTypes.None[int32]() + case 1: + + option590 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyStreamType(option590) + + default: + panic("unreachable") + } + var option593 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option593 = witTypes.None[string]() + case 1: + value592 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option593 = witTypes.Some[string](value592) + default: + panic("unreachable") + } + result595 := 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)) + 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) + } + + result597 := 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)) + value596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result597 = append(result597, value596) + } + + var option599 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option599 = witTypes.None[string]() + case 1: + value598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option599 = witTypes.Some[string](value598) + default: + panic("unreachable") + } + var option602 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option602 = witTypes.None[golem_core_types.Role]() + case 1: + var variant601 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant601 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant601 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant601 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value600 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant601 = golem_core_types.MakeRoleOther(value600) + + default: + panic("unreachable") + } + + option602 = witTypes.Some[golem_core_types.Role](variant601) + default: + panic("unreachable") + } + + result603 = append(result603, golem_core_types.SchemaTypeNode{variant591, golem_core_types.MetadataEnvelope{option593, result595, result597, option599, option602}}) + } + + result607 := 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)) + value604 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option606 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option606 = witTypes.None[string]() + case 1: + value605 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option606 = witTypes.Some[string](value605) + default: + panic("unreachable") + } + + result607 = append(result607, golem_core_types.SchemaTypeDef{value604, option606, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result631 := 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 variant630 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant630 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant630 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant630 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant630 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant630 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant630 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant630 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant630 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant630 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant630 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant630 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant630 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value608 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeStringValue(value608) + + case 13: + result609 := 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) + + result609 = append(result609, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeRecordValue(result609) + + case 14: + var option610 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option610 = witTypes.None[int32]() + case 1: + + option610 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option610}) + + case 15: + + variant630 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result611 := 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) + + result611 = append(result611, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant630 = golem_core_types.MakeSchemaValueNodeFlagsValue(result611) + + case 17: + 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))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeTupleValue(result612) + + case 18: + result613 := 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) + + result613 = append(result613, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeListValue(result613) + + case 19: + result614 := 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) + + result614 = append(result614, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeFixedListValue(result614) + + case 20: + result615 := 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) + + result615 = append(result615, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant630 = golem_core_types.MakeSchemaValueNodeMapValue(result615) + + case 21: + var option616 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option616 = witTypes.None[int32]() + case 1: + + option616 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeOptionValue(option616) + + case 22: + var variant619 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option617 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option617 = witTypes.None[int32]() + case 1: + + option617 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant619 = golem_core_types.MakeResultValuePayloadOkValue(option617) + + case 1: + var option618 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option618 = witTypes.None[int32]() + case 1: + + option618 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant619 = golem_core_types.MakeResultValuePayloadErrValue(option618) + + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeResultValue(variant619) + + case 23: + value620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option622 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option622 = witTypes.None[string]() + case 1: + value621 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option622 = witTypes.Some[string](value621) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value620, option622}) + + case 24: + value623 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option625 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option625 = witTypes.None[string]() + case 1: + value624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option625 = witTypes.Some[string](value624) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value623, option625}) + + case 25: + value626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodePathValue(value626) + + case 26: + value627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeUrlValue(value627) + + case 27: + + variant630 = 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: + + variant630 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value628}) + + case 30: + value629 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value629, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant630 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant630 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant630 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result631 = append(result631, variant630) + } + + option632 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result603, result607, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result631, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}) + default: + panic("unreachable") + } + + variant2472 = 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))), option632, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))) != 0)}) + + case 3: + var option837 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + option837 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result808 := 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 variant796 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant796 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant796 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option639 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option639 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option634 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant633 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant633 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant633 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option634 = witTypes.Some[golem_core_types.NumericBound](variant633) + default: + panic("unreachable") + } + var option636 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option636 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant635 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant635 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant635 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant635 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option636 = witTypes.Some[golem_core_types.NumericBound](variant635) + default: + panic("unreachable") + } + var option638 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option638 = witTypes.None[string]() + case 1: + value637 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option638 = witTypes.Some[string](value637) + default: + panic("unreachable") + } + + option639 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option634, option636, option638}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS8Type(option639) + + case 3: + var option646 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option646 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option641 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant640 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant640 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant640 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option641 = witTypes.Some[golem_core_types.NumericBound](variant640) + default: + panic("unreachable") + } + var option643 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option643 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant642 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant642 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant642 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant642 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option643 = witTypes.Some[golem_core_types.NumericBound](variant642) + default: + panic("unreachable") + } + var option645 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option645 = witTypes.None[string]() + case 1: + value644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option645 = witTypes.Some[string](value644) + default: + panic("unreachable") + } + + option646 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option641, option643, option645}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS16Type(option646) + + case 4: + var option653 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option653 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option648 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant647 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant647 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant647 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option648 = witTypes.Some[golem_core_types.NumericBound](variant647) + default: + panic("unreachable") + } + var option650 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option650 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant649 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant649 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant649 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant649 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option650 = witTypes.Some[golem_core_types.NumericBound](variant649) + default: + panic("unreachable") + } + var option652 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option652 = witTypes.None[string]() + case 1: + value651 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option652 = witTypes.Some[string](value651) + default: + panic("unreachable") + } + + option653 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option648, option650, option652}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS32Type(option653) + + case 5: + var option660 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option660 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option655 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant654 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant654 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant654 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option655 = witTypes.Some[golem_core_types.NumericBound](variant654) + default: + panic("unreachable") + } + var option657 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option657 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant656 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant656 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant656 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant656 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option657 = witTypes.Some[golem_core_types.NumericBound](variant656) + default: + panic("unreachable") + } + var option659 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option659 = witTypes.None[string]() + case 1: + value658 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option659 = witTypes.Some[string](value658) + default: + panic("unreachable") + } + + option660 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option655, option657, option659}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS64Type(option660) + + case 6: + var option667 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option667 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option662 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant661 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant661 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant661 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option662 = witTypes.Some[golem_core_types.NumericBound](variant661) + default: + panic("unreachable") + } + var option664 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option664 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant663 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant663 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant663 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant663 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option664 = witTypes.Some[golem_core_types.NumericBound](variant663) + default: + panic("unreachable") + } + var option666 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option666 = witTypes.None[string]() + case 1: + value665 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option666 = witTypes.Some[string](value665) + default: + panic("unreachable") + } + + option667 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option662, option664, option666}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU8Type(option667) + + case 7: + var option674 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option674 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option669 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant668 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant668 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant668 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option669 = witTypes.Some[golem_core_types.NumericBound](variant668) + default: + panic("unreachable") + } + var option671 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option671 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant670 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant670 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant670 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant670 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option671 = witTypes.Some[golem_core_types.NumericBound](variant670) + default: + panic("unreachable") + } + var option673 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option673 = witTypes.None[string]() + case 1: + value672 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option673 = witTypes.Some[string](value672) + default: + panic("unreachable") + } + + option674 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option669, option671, option673}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU16Type(option674) + + case 8: + var option681 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option681 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option676 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant675 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant675 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant675 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option676 = witTypes.Some[golem_core_types.NumericBound](variant675) + default: + panic("unreachable") + } + var option678 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option678 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant677 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant677 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant677 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant677 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option678 = witTypes.Some[golem_core_types.NumericBound](variant677) + default: + panic("unreachable") + } + var option680 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option680 = witTypes.None[string]() + case 1: + value679 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option680 = witTypes.Some[string](value679) + default: + panic("unreachable") + } + + option681 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option676, option678, option680}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU32Type(option681) + + case 9: + var option688 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option688 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option683 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant682 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant682 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant682 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option683 = witTypes.Some[golem_core_types.NumericBound](variant682) + default: + panic("unreachable") + } + var option685 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option685 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant684 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant684 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant684 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant684 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option685 = witTypes.Some[golem_core_types.NumericBound](variant684) + default: + panic("unreachable") + } + var option687 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option687 = witTypes.None[string]() + case 1: + value686 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option687 = witTypes.Some[string](value686) + default: + panic("unreachable") + } + + option688 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option683, option685, option687}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU64Type(option688) + + case 10: + var option695 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option695 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option690 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant689 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant689 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant689 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option690 = witTypes.Some[golem_core_types.NumericBound](variant689) + default: + panic("unreachable") + } + var option692 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option692 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant691 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant691 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant691 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant691 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option692 = witTypes.Some[golem_core_types.NumericBound](variant691) + default: + panic("unreachable") + } + var option694 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option694 = witTypes.None[string]() + case 1: + value693 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option694 = witTypes.Some[string](value693) + default: + panic("unreachable") + } + + option695 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option690, option692, option694}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyF32Type(option695) + + case 11: + var option702 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option702 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option697 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant696 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant696 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant696 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option697 = witTypes.Some[golem_core_types.NumericBound](variant696) + default: + panic("unreachable") + } + var option699 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option699 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant698 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant698 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant698 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant698 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option699 = witTypes.Some[golem_core_types.NumericBound](variant698) + default: + panic("unreachable") + } + var option701 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option701 = witTypes.None[string]() + case 1: + value700 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option701 = witTypes.Some[string](value700) + default: + panic("unreachable") + } + + option702 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option697, option699, option701}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyF64Type(option702) + + case 12: + + variant796 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant796 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result715 := 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)) + value703 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option705 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option705 = witTypes.None[string]() + case 1: + value704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option705 = witTypes.Some[string](value704) + default: + panic("unreachable") + } + result707 := 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)) + 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) + } + + result709 := 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)) + value708 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result709 = append(result709, value708) + } + + var option711 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option711 = witTypes.None[string]() + case 1: + value710 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option711 = witTypes.Some[string](value710) + default: + panic("unreachable") + } + var option714 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option714 = witTypes.None[golem_core_types.Role]() + case 1: + var variant713 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant713 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant713 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant713 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value712 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant713 = golem_core_types.MakeRoleOther(value712) + + default: + panic("unreachable") + } + + option714 = witTypes.Some[golem_core_types.Role](variant713) + default: + panic("unreachable") + } + + result715 = append(result715, golem_core_types.NamedFieldType{value703, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option705, result707, result709, option711, option714}}) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyRecordType(result715) + + case 15: + result729 := 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)) + value716 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option717 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option717 = witTypes.None[int32]() + case 1: + + option717 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option719 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option719 = witTypes.None[string]() + case 1: + value718 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option719 = witTypes.Some[string](value718) + default: + panic("unreachable") + } + result721 := 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)) + 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) + } + + result723 := 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)) + value722 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result723 = append(result723, value722) + } + + var option725 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option725 = witTypes.None[string]() + case 1: + value724 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option725 = witTypes.Some[string](value724) + default: + panic("unreachable") + } + var option728 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option728 = witTypes.None[golem_core_types.Role]() + case 1: + var variant727 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant727 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant727 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant727 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value726 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant727 = golem_core_types.MakeRoleOther(value726) + + default: + panic("unreachable") + } + + option728 = witTypes.Some[golem_core_types.Role](variant727) + default: + panic("unreachable") + } + + result729 = append(result729, golem_core_types.VariantCaseType{value716, option717, golem_core_types.MetadataEnvelope{option719, result721, result723, option725, option728}}) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyVariantType(result729) + + case 16: + 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) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyEnumType(result731) + + case 17: + result733 := 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)) + value732 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result733 = append(result733, value732) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyFlagsType(result733) + + case 18: + result734 := 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) + + result734 = append(result734, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyTupleType(result734) + + case 19: + + variant796 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant796 = 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: + + variant796 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant796 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option735 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option735 = witTypes.None[int32]() + case 1: + + option735 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option736 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option736 = witTypes.None[int32]() + case 1: + + option736 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option735, option736}) + + case 24: + var option739 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option739 = witTypes.None[[]string]() + case 1: + result738 := 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)) + 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) + } + + option739 = witTypes.Some[[]string](result738) + default: + panic("unreachable") + } + var option740 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option740 = witTypes.None[uint32]() + case 1: + + option740 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option741 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option741 = witTypes.None[uint32]() + case 1: + + option741 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option743 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option743 = witTypes.None[string]() + case 1: + value742 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option743 = witTypes.Some[string](value742) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option739, option740, option741, option743}) + + case 25: + var option746 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option746 = witTypes.None[[]string]() + case 1: + result745 := 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)) + value744 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result745 = append(result745, value744) + } + + option746 = witTypes.Some[[]string](result745) + default: + panic("unreachable") + } + var option747 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option747 = witTypes.None[uint32]() + case 1: + + option747 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option748 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option748 = witTypes.None[uint32]() + case 1: + + option748 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option746, option747, option748}) + + case 26: + var option751 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option751 = witTypes.None[[]string]() + case 1: + result750 := 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)) + value749 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result750 = append(result750, value749) + } + + option751 = witTypes.Some[[]string](result750) + default: + panic("unreachable") + } + var option754 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option754 = witTypes.None[[]string]() + case 1: + result753 := 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)) + 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") + } + + variant796 = 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)))), option751, option754}) + + case 27: + var option757 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option757 = witTypes.None[[]string]() + case 1: + result756 := 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)) + value755 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result756 = append(result756, value755) + } + + option757 = witTypes.Some[[]string](result756) + default: + panic("unreachable") + } + var option760 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option760 = witTypes.None[[]string]() + case 1: + result759 := 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)) + value758 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result759 = append(result759, value758) + } + + option760 = witTypes.Some[[]string](result759) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option757, option760}) + + case 28: + + variant796 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant796 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value761 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result763 := 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)) + value762 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result763 = append(result763, value762) + } + + var option765 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option765 = 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))), value764}) + default: + panic("unreachable") + } + var option767 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option767 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value766 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option767 = 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))), value766}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value761, result763, option765, option767}) + + case 31: + result789 := 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)) + value768 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant777 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value769 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRulePrefix(value769) + + case 1: + value770 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleSuffix(value770) + + case 2: + value771 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleContains(value771) + + case 3: + value772 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleRegex(value772) + + case 4: + value773 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option775 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option775 = witTypes.None[string]() + case 1: + value774 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option775 = witTypes.Some[string](value774) + default: + panic("unreachable") + } + + variant777 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value773, option775}) + + case 5: + value776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value776) + + default: + panic("unreachable") + } + var option779 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option779 = witTypes.None[string]() + case 1: + value778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option779 = witTypes.Some[string](value778) + default: + panic("unreachable") + } + result781 := 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)) + 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) + } + + result783 := 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)) + value782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result783 = append(result783, value782) + } + + var option785 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option785 = witTypes.None[string]() + case 1: + value784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option785 = witTypes.Some[string](value784) + default: + panic("unreachable") + } + var option788 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option788 = witTypes.None[golem_core_types.Role]() + case 1: + var variant787 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant787 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant787 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant787 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant787 = golem_core_types.MakeRoleOther(value786) + + default: + panic("unreachable") + } + + option788 = witTypes.Some[golem_core_types.Role](variant787) + default: + panic("unreachable") + } + + result789 = append(result789, golem_core_types.UnionBranch{value768, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant777, golem_core_types.MetadataEnvelope{option779, result781, result783, option785, option788}}) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result789}) + + case 32: + var option791 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option791 = witTypes.None[string]() + case 1: + value790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option791 = witTypes.Some[string](value790) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option791}) + + case 33: + var option793 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option793 = witTypes.None[string]() + case 1: + value792 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option793 = witTypes.Some[string](value792) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option793}) + + case 34: + + variant796 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option794 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option794 = witTypes.None[int32]() + case 1: + + option794 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyFutureType(option794) + + case 36: + var option795 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option795 = witTypes.None[int32]() + case 1: + + option795 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyStreamType(option795) + + default: + panic("unreachable") + } + var option798 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option798 = witTypes.None[string]() + case 1: + value797 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option798 = witTypes.Some[string](value797) + default: + panic("unreachable") + } + result800 := 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)) + 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) + } + + result802 := 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)) + value801 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result802 = append(result802, value801) + } + + var option804 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option804 = witTypes.None[string]() + case 1: + value803 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option804 = witTypes.Some[string](value803) + default: + panic("unreachable") + } + var option807 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option807 = witTypes.None[golem_core_types.Role]() + case 1: + var variant806 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant806 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant806 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant806 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value805 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant806 = golem_core_types.MakeRoleOther(value805) + + default: + panic("unreachable") + } + + option807 = witTypes.Some[golem_core_types.Role](variant806) + default: + panic("unreachable") + } + + result808 = append(result808, golem_core_types.SchemaTypeNode{variant796, golem_core_types.MetadataEnvelope{option798, result800, result802, option804, option807}}) + } + + result812 := 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)) + value809 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option811 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option811 = witTypes.None[string]() + case 1: + value810 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option811 = witTypes.Some[string](value810) + default: + panic("unreachable") + } + + result812 = append(result812, golem_core_types.SchemaTypeDef{value809, option811, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result836 := 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 variant835 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant835 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant835 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant835 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant835 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant835 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant835 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant835 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant835 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant835 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant835 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant835 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant835 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value813 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeStringValue(value813) + + case 13: + result814 := 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) + + result814 = append(result814, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeRecordValue(result814) + + case 14: + var option815 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option815 = witTypes.None[int32]() + case 1: + + option815 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option815}) + + case 15: + + variant835 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result816 := 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) + + result816 = append(result816, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant835 = golem_core_types.MakeSchemaValueNodeFlagsValue(result816) + + case 17: + 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))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeTupleValue(result817) + + case 18: + result818 := 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) + + result818 = append(result818, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeListValue(result818) + + case 19: + result819 := 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) + + result819 = append(result819, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeFixedListValue(result819) + + case 20: + result820 := 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) + + result820 = append(result820, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant835 = golem_core_types.MakeSchemaValueNodeMapValue(result820) + + case 21: + var option821 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option821 = witTypes.None[int32]() + case 1: + + option821 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeOptionValue(option821) + + case 22: + var variant824 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option822 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option822 = witTypes.None[int32]() + case 1: + + option822 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant824 = golem_core_types.MakeResultValuePayloadOkValue(option822) + + case 1: + var option823 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option823 = witTypes.None[int32]() + case 1: + + option823 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant824 = golem_core_types.MakeResultValuePayloadErrValue(option823) + + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeResultValue(variant824) + + case 23: + value825 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option827 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option827 = witTypes.None[string]() + case 1: + value826 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option827 = witTypes.Some[string](value826) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value825, option827}) + + case 24: + value828 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option830 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option830 = witTypes.None[string]() + case 1: + value829 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option830 = witTypes.Some[string](value829) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value828, option830}) + + case 25: + value831 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodePathValue(value831) + + case 26: + value832 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeUrlValue(value832) + + case 27: + + variant835 = 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: + + variant835 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value833 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value833}) + + case 30: + value834 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value834, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant835 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant835 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant835 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result836 = append(result836, variant835) + } + + option837 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result808, result812, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result836, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}) + default: + panic("unreachable") + } + + variant2472 = 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))), option837}) + + case 4: + var variant1282 AgentInvocation + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + value838 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + result1014 := 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 variant1002 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1002 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1002 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option845 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option845 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option840 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant839 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant839 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant839 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option840 = witTypes.Some[golem_core_types.NumericBound](variant839) + default: + panic("unreachable") + } + var option842 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option842 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant841 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant841 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant841 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant841 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option842 = witTypes.Some[golem_core_types.NumericBound](variant841) + default: + panic("unreachable") + } + var option844 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option844 = witTypes.None[string]() + case 1: + value843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option844 = witTypes.Some[string](value843) + default: + panic("unreachable") + } + + option845 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option840, option842, option844}) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS8Type(option845) + + case 3: + var option852 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option852 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option847 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant846 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant846 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant846 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option847 = witTypes.Some[golem_core_types.NumericBound](variant846) + default: + panic("unreachable") + } + var option849 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option849 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant848 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant848 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant848 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant848 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option849 = witTypes.Some[golem_core_types.NumericBound](variant848) + default: + panic("unreachable") + } + var option851 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option851 = witTypes.None[string]() + case 1: + value850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option851 = witTypes.Some[string](value850) + default: + panic("unreachable") + } + + option852 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option847, option849, option851}) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS16Type(option852) + + case 4: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS32Type(option859) + + case 5: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS64Type(option866) + + case 6: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU8Type(option873) + + case 7: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU16Type(option880) + + case 8: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU32Type(option887) + + case 9: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU64Type(option894) + + case 10: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyF32Type(option901) + + case 11: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyF64Type(option908) + + case 12: + + variant1002 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1002 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result921 := 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)) + value909 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option911 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option911 = witTypes.None[string]() + case 1: + value910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option911 = witTypes.Some[string](value910) + default: + panic("unreachable") + } + result913 := 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)) + 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) + } + + result915 := 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)) + value914 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result915 = append(result915, value914) + } + + var option917 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option917 = witTypes.None[string]() + case 1: + value916 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option917 = witTypes.Some[string](value916) + default: + panic("unreachable") + } + var option920 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option920 = witTypes.None[golem_core_types.Role]() + case 1: + var variant919 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant919 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant919 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant919 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value918 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant919 = golem_core_types.MakeRoleOther(value918) + + default: + panic("unreachable") + } + + option920 = witTypes.Some[golem_core_types.Role](variant919) + default: + panic("unreachable") + } + + result921 = append(result921, golem_core_types.NamedFieldType{value909, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option911, result913, result915, option917, option920}}) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyRecordType(result921) + + case 15: + result935 := 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)) + value922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option923 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option923 = witTypes.None[int32]() + case 1: + + option923 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option925 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option925 = witTypes.None[string]() + case 1: + value924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option925 = witTypes.Some[string](value924) + default: + panic("unreachable") + } + result927 := 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)) + 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), (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)) + 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), (8 + 9*4)))) { + case 0: + + option931 = witTypes.None[string]() + case 1: + value930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*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), (8 + 12*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), (8 + 13*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), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*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.VariantCaseType{value922, option923, golem_core_types.MetadataEnvelope{option925, result927, result929, option931, option934}}) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyVariantType(result935) + + case 16: + 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) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyEnumType(result937) + + case 17: + result939 := 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)) + value938 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result939 = append(result939, value938) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyFlagsType(result939) + + case 18: + result940 := 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) + + result940 = append(result940, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyTupleType(result940) + + case 19: + + variant1002 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1002 = 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: + + variant1002 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1002 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option941 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option941 = witTypes.None[int32]() + case 1: + + option941 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option942 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option942 = witTypes.None[int32]() + case 1: + + option942 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option941, option942}) + + case 24: + var option945 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option945 = witTypes.None[[]string]() + case 1: + result944 := 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)) + value943 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result944 = append(result944, value943) + } + + option945 = witTypes.Some[[]string](result944) + default: + panic("unreachable") + } + var option946 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option946 = witTypes.None[uint32]() + case 1: + + option946 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option947 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option947 = witTypes.None[uint32]() + case 1: + + option947 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option949 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option949 = witTypes.None[string]() + case 1: + value948 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option949 = witTypes.Some[string](value948) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option945, option946, option947, option949}) + + case 25: + var option952 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option952 = witTypes.None[[]string]() + case 1: + result951 := 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)) + 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) + } + + option952 = witTypes.Some[[]string](result951) + default: + panic("unreachable") + } + var option953 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option953 = witTypes.None[uint32]() + case 1: + + option953 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option954 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option954 = witTypes.None[uint32]() + case 1: + + option954 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option952, option953, option954}) + + case 26: + var option957 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option957 = witTypes.None[[]string]() + case 1: + result956 := 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)) + value955 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result956 = append(result956, value955) + } + + option957 = witTypes.Some[[]string](result956) + default: + panic("unreachable") + } + var option960 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option960 = witTypes.None[[]string]() + case 1: + result959 := 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)) + value958 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result959 = append(result959, value958) + } + + option960 = witTypes.Some[[]string](result959) + default: + panic("unreachable") + } + + variant1002 = 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)))), option957, option960}) + + case 27: + var option963 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option963 = witTypes.None[[]string]() + case 1: + result962 := 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)) + value961 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result962 = append(result962, value961) + } + + option963 = witTypes.Some[[]string](result962) + default: + panic("unreachable") + } + var option966 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option966 = witTypes.None[[]string]() + case 1: + result965 := 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)) + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option963, option966}) + + case 28: + + variant1002 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1002 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value967 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result969 := 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)) + value968 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result969 = append(result969, value968) + } + + var option971 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option971 = 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))), value970}) + default: + panic("unreachable") + } + var option973 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option973 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value972 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option973 = 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))), value972}) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value967, result969, option971, option973}) + + case 31: + result995 := 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)) + value974 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant983 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value975 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRulePrefix(value975) + + case 1: + value976 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleSuffix(value976) + + case 2: + value977 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleContains(value977) + + case 3: + value978 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleRegex(value978) + + case 4: + value979 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option981 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option981 = witTypes.None[string]() + case 1: + value980 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option981 = witTypes.Some[string](value980) + default: + panic("unreachable") + } + + variant983 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value979, option981}) + + case 5: + value982 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value982) + + default: + panic("unreachable") + } + var option985 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option985 = witTypes.None[string]() + case 1: + value984 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option985 = witTypes.Some[string](value984) + default: + panic("unreachable") + } + result987 := 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)) + 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) + } + + result989 := 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)) + value988 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result989 = append(result989, value988) + } + + var option991 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option991 = witTypes.None[string]() + case 1: + value990 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option991 = witTypes.Some[string](value990) + default: + panic("unreachable") + } + var option994 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option994 = witTypes.None[golem_core_types.Role]() + case 1: + var variant993 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant993 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant993 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant993 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value992 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant993 = golem_core_types.MakeRoleOther(value992) + + default: + panic("unreachable") + } + + option994 = witTypes.Some[golem_core_types.Role](variant993) + default: + panic("unreachable") + } + + result995 = append(result995, golem_core_types.UnionBranch{value974, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant983, golem_core_types.MetadataEnvelope{option985, result987, result989, option991, option994}}) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result995}) + + case 32: + var option997 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option997 = witTypes.None[string]() + case 1: + value996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option997 = witTypes.Some[string](value996) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option997}) + + case 33: + var option999 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option999 = witTypes.None[string]() + case 1: + value998 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option999 = witTypes.Some[string](value998) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option999}) + + case 34: + + variant1002 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1000 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1000 = witTypes.None[int32]() + case 1: + + option1000 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyFutureType(option1000) + + case 36: + var option1001 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1001 = witTypes.None[int32]() + case 1: + + option1001 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyStreamType(option1001) + + default: + panic("unreachable") + } + var option1004 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1004 = witTypes.None[string]() + case 1: + value1003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1004 = witTypes.Some[string](value1003) + default: + panic("unreachable") + } + result1006 := 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)) + 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) + } + + result1008 := 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)) + value1007 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1008 = append(result1008, value1007) + } + + var option1010 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1010 = witTypes.None[string]() + case 1: + value1009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1010 = witTypes.Some[string](value1009) + default: + panic("unreachable") + } + var option1013 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1013 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1012 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1012 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1012 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1012 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1011 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1012 = golem_core_types.MakeRoleOther(value1011) + + default: + panic("unreachable") + } + + option1013 = witTypes.Some[golem_core_types.Role](variant1012) + default: + panic("unreachable") + } + + result1014 = append(result1014, golem_core_types.SchemaTypeNode{variant1002, golem_core_types.MetadataEnvelope{option1004, result1006, result1008, option1010, option1013}}) + } + + result1018 := 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)) + value1015 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1017 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1017 = witTypes.None[string]() + case 1: + value1016 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1017 = witTypes.Some[string](value1016) + default: + panic("unreachable") + } + + result1018 = append(result1018, golem_core_types.SchemaTypeDef{value1015, option1017, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1042 := 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 variant1041 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1041 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1041 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1041 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1041 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1041 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1041 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1041 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1041 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1041 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1041 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1041 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1041 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1019 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeStringValue(value1019) + + case 13: + result1020 := 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) + + result1020 = append(result1020, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeRecordValue(result1020) + + case 14: + var option1021 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1021 = witTypes.None[int32]() + case 1: + + option1021 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1021}) + + case 15: + + variant1041 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1022 := 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) + + result1022 = append(result1022, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1022) + + case 17: + 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))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeTupleValue(result1023) + + case 18: + result1024 := 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) + + result1024 = append(result1024, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeListValue(result1024) + + case 19: + result1025 := 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) + + result1025 = append(result1025, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1025) + + case 20: + result1026 := 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) + + result1026 = append(result1026, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeMapValue(result1026) + + case 21: + var option1027 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1027 = witTypes.None[int32]() + case 1: + + option1027 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeOptionValue(option1027) + + case 22: + var variant1030 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1028 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1028 = witTypes.None[int32]() + case 1: + + option1028 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1030 = golem_core_types.MakeResultValuePayloadOkValue(option1028) + + case 1: + var option1029 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1029 = witTypes.None[int32]() + case 1: + + option1029 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1030 = golem_core_types.MakeResultValuePayloadErrValue(option1029) + + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeResultValue(variant1030) + + case 23: + value1031 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1033 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1033 = witTypes.None[string]() + case 1: + value1032 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1033 = witTypes.Some[string](value1032) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1031, option1033}) + + case 24: + value1034 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1036 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1036 = witTypes.None[string]() + case 1: + value1035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1036 = witTypes.Some[string](value1035) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1034, option1036}) + + case 25: + value1037 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodePathValue(value1037) + + case 26: + value1038 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeUrlValue(value1038) + + case 27: + + variant1041 = 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: + + variant1041 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1039 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1039}) + + case 30: + value1040 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1040, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1041 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1041 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1041 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1042 = append(result1042, variant1041) + } + + value1043 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))) + result1045 := 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)) + value1044 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1045 = append(result1045, value1044) + } + + result1057 := 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)) + result1056 := 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 variant1055 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1046 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1048 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1048 = witTypes.None[string]() + case 1: + value1047 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1048 = witTypes.Some[string](value1047) + default: + panic("unreachable") + } + var option1049 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1049 = witTypes.None[uint64]() + case 1: + + option1049 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1053 := 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)) + value1050 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1052 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1051 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1052 = golem_api_context.MakeAttributeValueString(value1051) + + default: + panic("unreachable") + } + + result1053 = append(result1053, golem_api_context.Attribute{value1050, variant1052}) + } + + variant1055 = MakeSpanDataLocalSpan(LocalSpanData{value1046, 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))))}, option1048, option1049, result1053, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1054 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1055 = MakeSpanDataExternalSpan(ExternalSpanData{value1054}) + + default: + panic("unreachable") + } + + result1056 = append(result1056, variant1055) + } + + result1057 = append(result1057, result1056) + } + + variant1282 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value838, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1014, result1018, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result1042, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value1043, result1045, result1057}) + + case 1: + value1058 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value1059 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + result1235 := 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 variant1223 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1223 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1223 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1066 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1066 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1061 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1060 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1060 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1060 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1061 = witTypes.Some[golem_core_types.NumericBound](variant1060) + default: + panic("unreachable") + } + var option1063 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1063 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1062 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1062 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1062 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1062 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1063 = witTypes.Some[golem_core_types.NumericBound](variant1062) + default: + panic("unreachable") + } + var option1065 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1065 = witTypes.None[string]() + case 1: + value1064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1065 = witTypes.Some[string](value1064) + default: + panic("unreachable") + } + + option1066 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1061, option1063, option1065}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS8Type(option1066) + + case 3: + var option1073 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1073 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1068 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1067 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1067 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1067 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1068 = witTypes.Some[golem_core_types.NumericBound](variant1067) + default: + panic("unreachable") + } + var option1070 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1070 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1069 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1069 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1069 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1069 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1070 = witTypes.Some[golem_core_types.NumericBound](variant1069) + default: + panic("unreachable") + } + var option1072 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1072 = witTypes.None[string]() + case 1: + value1071 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1072 = witTypes.Some[string](value1071) + default: + panic("unreachable") + } + + option1073 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1068, option1070, option1072}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS16Type(option1073) + + case 4: + var option1080 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1080 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1075 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1074 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1074 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1074 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1075 = witTypes.Some[golem_core_types.NumericBound](variant1074) + default: + panic("unreachable") + } + var option1077 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1077 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1076 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1076 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1076 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1076 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1077 = witTypes.Some[golem_core_types.NumericBound](variant1076) + default: + panic("unreachable") + } + var option1079 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1079 = witTypes.None[string]() + case 1: + value1078 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1079 = witTypes.Some[string](value1078) + default: + panic("unreachable") + } + + option1080 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1075, option1077, option1079}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS32Type(option1080) + + case 5: + var option1087 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1087 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1082 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1081 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1081 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1081 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1082 = witTypes.Some[golem_core_types.NumericBound](variant1081) + default: + panic("unreachable") + } + var option1084 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1084 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1083 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1083 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1083 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1083 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1084 = witTypes.Some[golem_core_types.NumericBound](variant1083) + default: + panic("unreachable") + } + var option1086 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1086 = witTypes.None[string]() + case 1: + value1085 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1086 = witTypes.Some[string](value1085) + default: + panic("unreachable") + } + + option1087 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1082, option1084, option1086}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS64Type(option1087) + + case 6: + var option1094 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1094 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1089 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1088 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1088 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1088 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1089 = witTypes.Some[golem_core_types.NumericBound](variant1088) + default: + panic("unreachable") + } + var option1091 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1091 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1090 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1090 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1090 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1090 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1091 = witTypes.Some[golem_core_types.NumericBound](variant1090) + default: + panic("unreachable") + } + var option1093 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1093 = witTypes.None[string]() + case 1: + value1092 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1093 = witTypes.Some[string](value1092) + default: + panic("unreachable") + } + + option1094 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1089, option1091, option1093}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU8Type(option1094) + + case 7: + var option1101 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1101 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1096 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1095 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1095 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1095 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1096 = witTypes.Some[golem_core_types.NumericBound](variant1095) + default: + panic("unreachable") + } + var option1098 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1098 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1097 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1097 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1097 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1097 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1098 = witTypes.Some[golem_core_types.NumericBound](variant1097) + default: + panic("unreachable") + } + var option1100 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1100 = witTypes.None[string]() + case 1: + value1099 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1100 = witTypes.Some[string](value1099) + default: + panic("unreachable") + } + + option1101 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1096, option1098, option1100}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU16Type(option1101) + + case 8: + var option1108 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1108 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1103 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1103 = witTypes.Some[golem_core_types.NumericBound](variant1102) + default: + panic("unreachable") + } + var option1105 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1105 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1104 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1104 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1104 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1104 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1105 = witTypes.Some[golem_core_types.NumericBound](variant1104) + default: + panic("unreachable") + } + var option1107 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1107 = witTypes.None[string]() + case 1: + value1106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1107 = witTypes.Some[string](value1106) + default: + panic("unreachable") + } + + option1108 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1103, option1105, option1107}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU32Type(option1108) + + case 9: + var option1115 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1115 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1110 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1109 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1109 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1109 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1110 = witTypes.Some[golem_core_types.NumericBound](variant1109) + default: + panic("unreachable") + } + var option1112 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1112 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1111 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1111 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1111 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1111 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1112 = witTypes.Some[golem_core_types.NumericBound](variant1111) + default: + panic("unreachable") + } + var option1114 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1114 = witTypes.None[string]() + case 1: + value1113 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1114 = witTypes.Some[string](value1113) + default: + panic("unreachable") + } + + option1115 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1110, option1112, option1114}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU64Type(option1115) + + case 10: + var option1122 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1122 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1117 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1116 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1116 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1116 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1117 = witTypes.Some[golem_core_types.NumericBound](variant1116) + default: + panic("unreachable") + } + var option1119 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1119 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1118 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1118 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1118 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1118 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1119 = witTypes.Some[golem_core_types.NumericBound](variant1118) + default: + panic("unreachable") + } + var option1121 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1121 = witTypes.None[string]() + case 1: + value1120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1121 = witTypes.Some[string](value1120) + default: + panic("unreachable") + } + + option1122 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1117, option1119, option1121}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyF32Type(option1122) + + case 11: + var option1129 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1129 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1124 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1123 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1123 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1123 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1124 = witTypes.Some[golem_core_types.NumericBound](variant1123) + default: + panic("unreachable") + } + var option1126 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1126 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1125 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1125 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1125 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1125 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1126 = witTypes.Some[golem_core_types.NumericBound](variant1125) + default: + panic("unreachable") + } + var option1128 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1128 = witTypes.None[string]() + case 1: + value1127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1128 = witTypes.Some[string](value1127) + default: + panic("unreachable") + } + + option1129 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1124, option1126, option1128}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyF64Type(option1129) + + case 12: + + variant1223 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1223 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1142 := 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)) + value1130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1132 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1132 = witTypes.None[string]() + case 1: + value1131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1132 = witTypes.Some[string](value1131) + default: + panic("unreachable") + } + result1134 := 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)) + 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) + } + + result1136 := 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)) + value1135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1136 = append(result1136, value1135) + } + + var option1138 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1138 = witTypes.None[string]() + case 1: + value1137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1138 = witTypes.Some[string](value1137) + default: + panic("unreachable") + } + var option1141 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1141 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1140 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1140 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1140 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1140 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1140 = golem_core_types.MakeRoleOther(value1139) + + default: + panic("unreachable") + } + + option1141 = witTypes.Some[golem_core_types.Role](variant1140) + default: + panic("unreachable") + } + + result1142 = append(result1142, golem_core_types.NamedFieldType{value1130, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1132, result1134, result1136, option1138, option1141}}) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyRecordType(result1142) + + case 15: + result1156 := 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)) + value1143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1144 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1144 = witTypes.None[int32]() + case 1: + + option1144 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1146 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1146 = witTypes.None[string]() + case 1: + value1145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1146 = witTypes.Some[string](value1145) + default: + panic("unreachable") + } + result1148 := 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)) + 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) + } + + result1150 := 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)) + value1149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1150 = append(result1150, value1149) + } + + var option1152 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1152 = witTypes.None[string]() + case 1: + value1151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1152 = witTypes.Some[string](value1151) + default: + panic("unreachable") + } + var option1155 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1155 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1154 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1154 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1154 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1154 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1154 = golem_core_types.MakeRoleOther(value1153) + + default: + panic("unreachable") + } + + option1155 = witTypes.Some[golem_core_types.Role](variant1154) + default: + panic("unreachable") + } + + result1156 = append(result1156, golem_core_types.VariantCaseType{value1143, option1144, golem_core_types.MetadataEnvelope{option1146, result1148, result1150, option1152, option1155}}) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyVariantType(result1156) + + case 16: + 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) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyEnumType(result1158) + + case 17: + result1160 := 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)) + value1159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1160 = append(result1160, value1159) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1160) + + case 18: + result1161 := 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) + + result1161 = append(result1161, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyTupleType(result1161) + + case 19: + + variant1223 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1223 = 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: + + variant1223 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1223 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1162 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1162 = witTypes.None[int32]() + case 1: + + option1162 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1163 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1163 = witTypes.None[int32]() + case 1: + + option1163 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1162, option1163}) + + case 24: + var option1166 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1166 = witTypes.None[[]string]() + case 1: + result1165 := 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)) + value1164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1165 = append(result1165, value1164) + } + + option1166 = witTypes.Some[[]string](result1165) + default: + panic("unreachable") + } + var option1167 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1167 = witTypes.None[uint32]() + case 1: + + option1167 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1168 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1168 = witTypes.None[uint32]() + case 1: + + option1168 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1170 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1170 = witTypes.None[string]() + case 1: + value1169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1170 = witTypes.Some[string](value1169) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1166, option1167, option1168, option1170}) + + case 25: + var option1173 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1173 = witTypes.None[[]string]() + case 1: + result1172 := 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)) + value1171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1172 = append(result1172, value1171) + } + + option1173 = witTypes.Some[[]string](result1172) + default: + panic("unreachable") + } + var option1174 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1174 = witTypes.None[uint32]() + case 1: + + option1174 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1175 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1175 = witTypes.None[uint32]() + case 1: + + option1175 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1173, option1174, option1175}) + + case 26: + var option1178 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1178 = witTypes.None[[]string]() + case 1: + result1177 := 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)) + value1176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1177 = append(result1177, value1176) + } + + option1178 = witTypes.Some[[]string](result1177) + default: + panic("unreachable") + } + var option1181 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1181 = witTypes.None[[]string]() + case 1: + result1180 := 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)) + value1179 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1180 = append(result1180, value1179) + } + + option1181 = witTypes.Some[[]string](result1180) + default: + panic("unreachable") + } + + variant1223 = 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)))), option1178, option1181}) + + case 27: + var option1184 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1184 = witTypes.None[[]string]() + case 1: + result1183 := 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)) + value1182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1183 = append(result1183, value1182) + } + + option1184 = witTypes.Some[[]string](result1183) + default: + panic("unreachable") + } + var option1187 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1187 = witTypes.None[[]string]() + case 1: + result1186 := 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)) + value1185 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1186 = append(result1186, value1185) + } + + option1187 = witTypes.Some[[]string](result1186) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1184, option1187}) + + case 28: + + variant1223 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1223 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1190 := 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)) + value1189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1190 = append(result1190, value1189) + } + + var option1192 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1192 = 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))), value1191}) + default: + panic("unreachable") + } + var option1194 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1194 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1194 = 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))), value1193}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1188, result1190, option1192, option1194}) + + case 31: + result1216 := 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)) + value1195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1204 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRulePrefix(value1196) + + case 1: + value1197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleSuffix(value1197) + + case 2: + value1198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleContains(value1198) + + case 3: + value1199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleRegex(value1199) + + case 4: + value1200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1202 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1202 = witTypes.None[string]() + case 1: + value1201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1202 = witTypes.Some[string](value1201) + default: + panic("unreachable") + } + + variant1204 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1200, option1202}) + + case 5: + value1203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1203) + + default: + panic("unreachable") + } + var option1206 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1206 = witTypes.None[string]() + case 1: + value1205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1206 = witTypes.Some[string](value1205) + default: + panic("unreachable") + } + result1208 := 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)) + 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) + } + + result1210 := 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)) + value1209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1210 = append(result1210, value1209) + } + + var option1212 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1212 = witTypes.None[string]() + case 1: + value1211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1212 = witTypes.Some[string](value1211) + default: + panic("unreachable") + } + var option1215 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1215 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1214 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1214 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1214 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1214 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1214 = golem_core_types.MakeRoleOther(value1213) + + default: + panic("unreachable") + } + + option1215 = witTypes.Some[golem_core_types.Role](variant1214) + default: + panic("unreachable") + } + + result1216 = append(result1216, golem_core_types.UnionBranch{value1195, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1204, golem_core_types.MetadataEnvelope{option1206, result1208, result1210, option1212, option1215}}) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1216}) + + case 32: + var option1218 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1218 = witTypes.None[string]() + case 1: + value1217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1218 = witTypes.Some[string](value1217) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1218}) + + case 33: + var option1220 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1220 = witTypes.None[string]() + case 1: + value1219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1220 = witTypes.Some[string](value1219) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1220}) + + case 34: + + variant1223 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyFutureType(option1221) + + case 36: + var option1222 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1222 = witTypes.None[int32]() + case 1: + + option1222 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyStreamType(option1222) + + default: + panic("unreachable") + } + var option1225 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1225 = witTypes.None[string]() + case 1: + value1224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1225 = witTypes.Some[string](value1224) + default: + panic("unreachable") + } + result1227 := 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)) + 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) + } + + result1229 := 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)) + value1228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1229 = append(result1229, value1228) + } + + var option1231 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1231 = witTypes.None[string]() + case 1: + value1230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1231 = witTypes.Some[string](value1230) + default: + panic("unreachable") + } + var option1234 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1234 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1233 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1233 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1233 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1233 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1233 = golem_core_types.MakeRoleOther(value1232) + + default: + panic("unreachable") + } + + option1234 = witTypes.Some[golem_core_types.Role](variant1233) + default: + panic("unreachable") + } + + result1235 = append(result1235, golem_core_types.SchemaTypeNode{variant1223, golem_core_types.MetadataEnvelope{option1225, result1227, result1229, option1231, option1234}}) + } + + result1239 := 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)) + value1236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1238 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1238 = witTypes.None[string]() + case 1: + value1237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1238 = witTypes.Some[string](value1237) + default: + panic("unreachable") + } + + result1239 = append(result1239, golem_core_types.SchemaTypeDef{value1236, option1238, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1263 := 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 variant1262 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1262 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1262 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1262 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1262 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1262 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1262 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1262 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1262 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1262 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1262 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1262 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1262 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1240 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeStringValue(value1240) + + case 13: + result1241 := 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) + + result1241 = append(result1241, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeRecordValue(result1241) + + case 14: + var option1242 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1242 = witTypes.None[int32]() + case 1: + + option1242 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1242}) + + case 15: + + variant1262 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1243 := 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) + + result1243 = append(result1243, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1243) + + case 17: + 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))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeTupleValue(result1244) + + case 18: + 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))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeListValue(result1245) + + case 19: + result1246 := 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) + + result1246 = append(result1246, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1246) + + case 20: + result1247 := 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) + + result1247 = append(result1247, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeMapValue(result1247) + + case 21: + var option1248 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1248 = witTypes.None[int32]() + case 1: + + option1248 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeOptionValue(option1248) + + case 22: + var variant1251 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant1251 = golem_core_types.MakeResultValuePayloadOkValue(option1249) + + case 1: + var option1250 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1250 = witTypes.None[int32]() + case 1: + + option1250 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1251 = golem_core_types.MakeResultValuePayloadErrValue(option1250) + + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeResultValue(variant1251) + + case 23: + value1252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1254 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1254 = witTypes.None[string]() + case 1: + value1253 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1254 = witTypes.Some[string](value1253) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1252, option1254}) + + case 24: + value1255 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1257 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1257 = witTypes.None[string]() + case 1: + value1256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1257 = witTypes.Some[string](value1256) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1255, option1257}) + + case 25: + value1258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodePathValue(value1258) + + case 26: + value1259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeUrlValue(value1259) + + case 27: + + variant1262 = 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: + + variant1262 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1260}) + + case 30: + value1261 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1261, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1262 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1262 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1262 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1263 = append(result1263, variant1262) + } + + value1264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))) + result1266 := 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)) + value1265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1266 = append(result1266, value1265) + } + + result1278 := 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)) + result1277 := 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 variant1276 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1267 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1269 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1269 = witTypes.None[string]() + case 1: + value1268 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1269 = witTypes.Some[string](value1268) + default: + panic("unreachable") + } + var option1270 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1270 = witTypes.None[uint64]() + case 1: + + option1270 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1274 := 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)) + value1271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1273 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1272 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1273 = golem_api_context.MakeAttributeValueString(value1272) + + default: + panic("unreachable") + } + + result1274 = append(result1274, golem_api_context.Attribute{value1271, variant1273}) + } + + variant1276 = MakeSpanDataLocalSpan(LocalSpanData{value1267, 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))))}, option1269, option1270, result1274, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1275 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1276 = MakeSpanDataExternalSpan(ExternalSpanData{value1275}) + + default: + panic("unreachable") + } + + result1277 = append(result1277, variant1276) + } + + result1278 = append(result1278, result1277) + } + + variant1282 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1058, value1059, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1235, result1239, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result1263, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value1264, result1266, result1278}) + + case 2: + + variant1282 = MakeAgentInvocationSaveSnapshot() + + case 3: + value1279 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value1280 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + variant1282 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value1279, value1280}}) + + case 4: + value1281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant1282 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value1281}) + + case 5: + + variant1282 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}) + + default: + panic("unreachable") + } + + variant2472 = 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)))}, variant1282}) + + case 5: + var variant1697 AgentInvocationResult + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + result1458 := 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 variant1446 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1446 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1446 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1289 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1289 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1284 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1284 = witTypes.Some[golem_core_types.NumericBound](variant1283) + default: + panic("unreachable") + } + var option1286 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1286 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1285 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1285 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1285 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1285 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1286 = witTypes.Some[golem_core_types.NumericBound](variant1285) + default: + panic("unreachable") + } + var option1288 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1288 = witTypes.None[string]() + case 1: + value1287 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1288 = witTypes.Some[string](value1287) + default: + panic("unreachable") + } + + option1289 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1284, option1286, option1288}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS8Type(option1289) + + case 3: + var option1296 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1296 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1291 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1290 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1290 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1290 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1291 = witTypes.Some[golem_core_types.NumericBound](variant1290) + default: + panic("unreachable") + } + var option1293 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1293 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1292 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1292 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1292 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1292 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1293 = witTypes.Some[golem_core_types.NumericBound](variant1292) + default: + panic("unreachable") + } + var option1295 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1295 = witTypes.None[string]() + case 1: + value1294 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1295 = witTypes.Some[string](value1294) + default: + panic("unreachable") + } + + option1296 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1291, option1293, option1295}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS16Type(option1296) + + case 4: + var option1303 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1303 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1298 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1297 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1297 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1297 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1298 = witTypes.Some[golem_core_types.NumericBound](variant1297) + default: + panic("unreachable") + } + var option1300 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1300 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1299 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1299 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1299 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1299 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1300 = witTypes.Some[golem_core_types.NumericBound](variant1299) + default: + panic("unreachable") + } + var option1302 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1302 = witTypes.None[string]() + case 1: + value1301 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1302 = witTypes.Some[string](value1301) + default: + panic("unreachable") + } + + option1303 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1298, option1300, option1302}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS32Type(option1303) + + case 5: + var option1310 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1310 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1305 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1304 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1304 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1304 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1305 = witTypes.Some[golem_core_types.NumericBound](variant1304) + default: + panic("unreachable") + } + var option1307 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1307 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1306 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1306 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1306 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1306 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1307 = witTypes.Some[golem_core_types.NumericBound](variant1306) + default: + panic("unreachable") + } + var option1309 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1309 = witTypes.None[string]() + case 1: + value1308 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1309 = witTypes.Some[string](value1308) + default: + panic("unreachable") + } + + option1310 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1305, option1307, option1309}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS64Type(option1310) + + case 6: + var option1317 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1317 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1312 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1311 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1311 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1311 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1312 = witTypes.Some[golem_core_types.NumericBound](variant1311) + default: + panic("unreachable") + } + var option1314 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1314 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1313 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1313 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1313 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1313 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1314 = witTypes.Some[golem_core_types.NumericBound](variant1313) + default: + panic("unreachable") + } + var option1316 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1316 = witTypes.None[string]() + case 1: + value1315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1316 = witTypes.Some[string](value1315) + default: + panic("unreachable") + } + + option1317 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1312, option1314, option1316}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU8Type(option1317) + + case 7: + var option1324 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1324 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1319 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1318 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1318 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1318 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1319 = witTypes.Some[golem_core_types.NumericBound](variant1318) + default: + panic("unreachable") + } + var option1321 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1321 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1320 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1320 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1320 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1320 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1321 = witTypes.Some[golem_core_types.NumericBound](variant1320) + default: + panic("unreachable") + } + var option1323 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1323 = witTypes.None[string]() + case 1: + value1322 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1323 = witTypes.Some[string](value1322) + default: + panic("unreachable") + } + + option1324 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1319, option1321, option1323}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU16Type(option1324) + + case 8: + var option1331 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1331 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1326 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1325 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1325 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1325 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1326 = witTypes.Some[golem_core_types.NumericBound](variant1325) + default: + panic("unreachable") + } + var option1328 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1328 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1327 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1327 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1327 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1327 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1328 = witTypes.Some[golem_core_types.NumericBound](variant1327) + default: + panic("unreachable") + } + var option1330 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1330 = witTypes.None[string]() + case 1: + value1329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1330 = witTypes.Some[string](value1329) + default: + panic("unreachable") + } + + option1331 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1326, option1328, option1330}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU32Type(option1331) + + case 9: + var option1338 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1338 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1333 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1332 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1332 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1332 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1333 = witTypes.Some[golem_core_types.NumericBound](variant1332) + default: + panic("unreachable") + } + var option1335 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1335 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1334 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1334 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1334 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1334 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1335 = witTypes.Some[golem_core_types.NumericBound](variant1334) + default: + panic("unreachable") + } + var option1337 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1337 = witTypes.None[string]() + case 1: + value1336 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1337 = witTypes.Some[string](value1336) + default: + panic("unreachable") + } + + option1338 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1333, option1335, option1337}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU64Type(option1338) + + case 10: + var option1345 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1345 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1340 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1339 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1339 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1339 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1340 = witTypes.Some[golem_core_types.NumericBound](variant1339) + default: + panic("unreachable") + } + var option1342 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1342 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1341 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1341 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1341 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1341 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1342 = witTypes.Some[golem_core_types.NumericBound](variant1341) + default: + panic("unreachable") + } + var option1344 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1344 = witTypes.None[string]() + case 1: + value1343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1344 = witTypes.Some[string](value1343) + default: + panic("unreachable") + } + + option1345 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1340, option1342, option1344}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyF32Type(option1345) + + case 11: + var option1352 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1352 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1347 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1346 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1346 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1346 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1347 = witTypes.Some[golem_core_types.NumericBound](variant1346) + default: + panic("unreachable") + } + var option1349 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1349 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1348 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1348 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1348 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1348 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1349 = witTypes.Some[golem_core_types.NumericBound](variant1348) + default: + panic("unreachable") + } + var option1351 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1351 = witTypes.None[string]() + case 1: + value1350 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1351 = witTypes.Some[string](value1350) + default: + panic("unreachable") + } + + option1352 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1347, option1349, option1351}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyF64Type(option1352) + + case 12: + + variant1446 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1446 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1365 := 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)) + value1353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1355 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1355 = witTypes.None[string]() + case 1: + value1354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1355 = witTypes.Some[string](value1354) + default: + panic("unreachable") + } + result1357 := 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)) + 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) + } + + result1359 := 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)) + value1358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1359 = append(result1359, value1358) + } + + var option1361 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1361 = witTypes.None[string]() + case 1: + value1360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1361 = witTypes.Some[string](value1360) + default: + panic("unreachable") + } + var option1364 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1364 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1363 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1363 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1363 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1363 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1362 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1363 = golem_core_types.MakeRoleOther(value1362) + + default: + panic("unreachable") + } + + option1364 = witTypes.Some[golem_core_types.Role](variant1363) + default: + panic("unreachable") + } + + result1365 = append(result1365, golem_core_types.NamedFieldType{value1353, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1355, result1357, result1359, option1361, option1364}}) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyRecordType(result1365) + + case 15: + result1379 := 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)) + value1366 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1367 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1367 = witTypes.None[int32]() + case 1: + + option1367 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1369 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1369 = witTypes.None[string]() + case 1: + value1368 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1369 = witTypes.Some[string](value1368) + default: + panic("unreachable") + } + result1371 := 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)) + 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) + } + + result1373 := 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)) + value1372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1373 = append(result1373, value1372) + } + + var option1375 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1375 = witTypes.None[string]() + case 1: + value1374 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1375 = witTypes.Some[string](value1374) + default: + panic("unreachable") + } + var option1378 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1378 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1377 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1377 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1377 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1377 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1376 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1377 = golem_core_types.MakeRoleOther(value1376) + + default: + panic("unreachable") + } + + option1378 = witTypes.Some[golem_core_types.Role](variant1377) + default: + panic("unreachable") + } + + result1379 = append(result1379, golem_core_types.VariantCaseType{value1366, option1367, golem_core_types.MetadataEnvelope{option1369, result1371, result1373, option1375, option1378}}) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyVariantType(result1379) + + case 16: + 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) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyEnumType(result1381) + + case 17: + result1383 := 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)) + value1382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1383 = append(result1383, value1382) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1383) + + case 18: + result1384 := 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) + + result1384 = append(result1384, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyTupleType(result1384) + + case 19: + + variant1446 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1446 = 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: + + variant1446 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1446 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1385 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1385 = witTypes.None[int32]() + case 1: + + option1385 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1386 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1386 = witTypes.None[int32]() + case 1: + + option1386 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1385, option1386}) + + case 24: + var option1389 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1389 = witTypes.None[[]string]() + case 1: + result1388 := 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)) + value1387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1388 = append(result1388, value1387) + } + + option1389 = witTypes.Some[[]string](result1388) + default: + panic("unreachable") + } + var option1390 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1390 = witTypes.None[uint32]() + case 1: + + option1390 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1391 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1391 = witTypes.None[uint32]() + case 1: + + option1391 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1393 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1393 = witTypes.None[string]() + case 1: + value1392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1393 = witTypes.Some[string](value1392) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1389, option1390, option1391, option1393}) + + case 25: + var option1396 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1396 = witTypes.None[[]string]() + case 1: + result1395 := 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)) + value1394 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1395 = append(result1395, value1394) + } + + option1396 = witTypes.Some[[]string](result1395) + default: + panic("unreachable") + } + var option1397 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1397 = witTypes.None[uint32]() + case 1: + + option1397 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1398 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1398 = witTypes.None[uint32]() + case 1: + + option1398 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1396, option1397, option1398}) + + case 26: + var option1401 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1401 = witTypes.None[[]string]() + case 1: + result1400 := 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)) + 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") + } + var option1404 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1404 = witTypes.None[[]string]() + case 1: + result1403 := 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)) + 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") + } + + variant1446 = 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)))), option1401, option1404}) + + case 27: + var option1407 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1407 = witTypes.None[[]string]() + case 1: + result1406 := 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)) + 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") + } + var option1410 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1410 = witTypes.None[[]string]() + case 1: + result1409 := 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)) + value1408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1409 = append(result1409, value1408) + } + + option1410 = witTypes.Some[[]string](result1409) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1407, option1410}) + + case 28: + + variant1446 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1446 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1413 := 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)) + value1412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1413 = append(result1413, value1412) + } + + var option1415 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1415 = 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))), value1414}) + default: + panic("unreachable") + } + var option1417 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1417 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1417 = 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))), value1416}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1411, result1413, option1415, option1417}) + + case 31: + result1439 := 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)) + value1418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1427 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRulePrefix(value1419) + + case 1: + value1420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleSuffix(value1420) + + case 2: + value1421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleContains(value1421) + + case 3: + value1422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleRegex(value1422) + + case 4: + value1423 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1425 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1425 = witTypes.None[string]() + case 1: + value1424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1425 = witTypes.Some[string](value1424) + default: + panic("unreachable") + } + + variant1427 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1423, option1425}) + + case 5: + value1426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1426) + + default: + panic("unreachable") + } + var option1429 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1429 = witTypes.None[string]() + case 1: + value1428 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1429 = witTypes.Some[string](value1428) + default: + panic("unreachable") + } + result1431 := 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)) + 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) + } + + result1433 := 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)) + value1432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1433 = append(result1433, value1432) + } + + var option1435 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1435 = witTypes.None[string]() + case 1: + value1434 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1435 = witTypes.Some[string](value1434) + default: + panic("unreachable") + } + var option1438 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1438 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1437 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1437 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1437 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1437 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1436 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1437 = golem_core_types.MakeRoleOther(value1436) + + default: + panic("unreachable") + } + + option1438 = witTypes.Some[golem_core_types.Role](variant1437) + default: + panic("unreachable") + } + + result1439 = append(result1439, golem_core_types.UnionBranch{value1418, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1427, golem_core_types.MetadataEnvelope{option1429, result1431, result1433, option1435, option1438}}) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1439}) + + case 32: + var option1441 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1441 = witTypes.None[string]() + case 1: + value1440 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1441 = witTypes.Some[string](value1440) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1441}) + + case 33: + var option1443 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1443 = witTypes.None[string]() + case 1: + value1442 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1443 = witTypes.Some[string](value1442) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1443}) + + case 34: + + variant1446 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1444 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1444 = witTypes.None[int32]() + case 1: + + option1444 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyFutureType(option1444) + + case 36: + var option1445 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1445 = witTypes.None[int32]() + case 1: + + option1445 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyStreamType(option1445) + + default: + panic("unreachable") + } + var option1448 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1448 = witTypes.None[string]() + case 1: + value1447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1448 = witTypes.Some[string](value1447) + default: + panic("unreachable") + } + result1450 := 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)) + 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) + } + + result1452 := 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)) + value1451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1452 = append(result1452, value1451) + } + + var option1454 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1454 = witTypes.None[string]() + case 1: + value1453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1454 = witTypes.Some[string](value1453) + default: + panic("unreachable") + } + var option1457 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1457 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1456 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1456 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1456 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1456 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1455 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1456 = golem_core_types.MakeRoleOther(value1455) + + default: + panic("unreachable") + } + + option1457 = witTypes.Some[golem_core_types.Role](variant1456) + default: + panic("unreachable") + } + + result1458 = append(result1458, golem_core_types.SchemaTypeNode{variant1446, golem_core_types.MetadataEnvelope{option1448, result1450, result1452, option1454, option1457}}) + } + + result1462 := 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)) + value1459 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1461 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1461 = witTypes.None[string]() + case 1: + value1460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1461 = witTypes.Some[string](value1460) + default: + panic("unreachable") + } + + result1462 = append(result1462, golem_core_types.SchemaTypeDef{value1459, option1461, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1486 := 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 variant1485 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1485 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1485 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1485 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1485 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1485 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1485 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1485 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1485 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1485 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1485 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1485 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1485 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeStringValue(value1463) + + case 13: + 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))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeRecordValue(result1464) + + case 14: + var option1465 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1465 = witTypes.None[int32]() + case 1: + + option1465 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1465}) + + case 15: + + variant1485 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1466 := 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) + + result1466 = append(result1466, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1466) + + case 17: + 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))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeTupleValue(result1467) + + case 18: + result1468 := 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) + + result1468 = append(result1468, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeListValue(result1468) + + case 19: + result1469 := 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) + + result1469 = append(result1469, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1469) + + case 20: + result1470 := 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) + + result1470 = append(result1470, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeMapValue(result1470) + + case 21: + var option1471 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1471 = witTypes.None[int32]() + case 1: + + option1471 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeOptionValue(option1471) + + case 22: + var variant1474 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1472 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1472 = witTypes.None[int32]() + case 1: + + option1472 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1474 = golem_core_types.MakeResultValuePayloadOkValue(option1472) + + case 1: + var option1473 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1473 = witTypes.None[int32]() + case 1: + + option1473 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1474 = golem_core_types.MakeResultValuePayloadErrValue(option1473) + + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeResultValue(variant1474) + + case 23: + value1475 := unsafe.String((*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") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1475, option1477}) + + case 24: + value1478 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1480 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1480 = witTypes.None[string]() + case 1: + value1479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1480 = witTypes.Some[string](value1479) + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1478, option1480}) + + case 25: + value1481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodePathValue(value1481) + + case 26: + value1482 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeUrlValue(value1482) + + case 27: + + variant1485 = 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: + + variant1485 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1483 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1483}) + + case 30: + value1484 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1484, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1485 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1485 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1485 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1486 = append(result1486, variant1485) + } + + variant1697 = MakeAgentInvocationResultAgentInitialization(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1458, result1462, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1486, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}}) + + case 1: + result1662 := 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 variant1650 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1650 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1650 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1493 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1493 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1488 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1487 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1487 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1487 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1488 = witTypes.Some[golem_core_types.NumericBound](variant1487) + default: + panic("unreachable") + } + var option1490 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1490 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1489 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1489 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1489 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1489 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1490 = witTypes.Some[golem_core_types.NumericBound](variant1489) + default: + panic("unreachable") + } + var option1492 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1492 = witTypes.None[string]() + case 1: + value1491 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1492 = witTypes.Some[string](value1491) + default: + panic("unreachable") + } + + option1493 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1488, option1490, option1492}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS8Type(option1493) + + case 3: + var option1500 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1500 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1495 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1494 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1494 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1494 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1495 = witTypes.Some[golem_core_types.NumericBound](variant1494) + default: + panic("unreachable") + } + var option1497 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1497 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1496 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1496 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1496 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1496 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1497 = witTypes.Some[golem_core_types.NumericBound](variant1496) + default: + panic("unreachable") + } + var option1499 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1499 = witTypes.None[string]() + case 1: + value1498 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1499 = witTypes.Some[string](value1498) + default: + panic("unreachable") + } + + option1500 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1495, option1497, option1499}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS16Type(option1500) + + case 4: + var option1507 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1507 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1502 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1501 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1501 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1501 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1502 = witTypes.Some[golem_core_types.NumericBound](variant1501) + default: + panic("unreachable") + } + var option1504 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1503 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1503 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1503 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1504 = witTypes.Some[golem_core_types.NumericBound](variant1503) + default: + panic("unreachable") + } + var option1506 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1506 = witTypes.None[string]() + case 1: + value1505 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1506 = witTypes.Some[string](value1505) + default: + panic("unreachable") + } + + option1507 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1502, option1504, option1506}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS32Type(option1507) + + case 5: + var option1514 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1514 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1509 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1508 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1508 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1508 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1509 = witTypes.Some[golem_core_types.NumericBound](variant1508) + default: + panic("unreachable") + } + var option1511 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1510 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1510 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1510 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1511 = witTypes.Some[golem_core_types.NumericBound](variant1510) + default: + panic("unreachable") + } + var option1513 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1513 = witTypes.None[string]() + case 1: + value1512 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1513 = witTypes.Some[string](value1512) + default: + panic("unreachable") + } + + option1514 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1509, option1511, option1513}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS64Type(option1514) + + case 6: + var option1521 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1521 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1516 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1515 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1515 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1515 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1516 = witTypes.Some[golem_core_types.NumericBound](variant1515) + default: + panic("unreachable") + } + var option1518 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1517 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1517 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1517 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1518 = witTypes.Some[golem_core_types.NumericBound](variant1517) + default: + panic("unreachable") + } + var option1520 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1520 = witTypes.None[string]() + case 1: + value1519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1520 = witTypes.Some[string](value1519) + default: + panic("unreachable") + } + + option1521 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1516, option1518, option1520}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU8Type(option1521) + + case 7: + var option1528 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1528 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1523 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1522 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1522 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1522 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1523 = witTypes.Some[golem_core_types.NumericBound](variant1522) + default: + panic("unreachable") + } + var option1525 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1524 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1524 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1524 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1525 = witTypes.Some[golem_core_types.NumericBound](variant1524) + default: + panic("unreachable") + } + var option1527 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1527 = witTypes.None[string]() + case 1: + value1526 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1527 = witTypes.Some[string](value1526) + default: + panic("unreachable") + } + + option1528 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1523, option1525, option1527}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU16Type(option1528) + + case 8: + var option1535 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1535 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1530 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1529 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1529 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1529 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1530 = witTypes.Some[golem_core_types.NumericBound](variant1529) + default: + panic("unreachable") + } + var option1532 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1531 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1531 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1531 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1532 = witTypes.Some[golem_core_types.NumericBound](variant1531) + default: + panic("unreachable") + } + var option1534 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1534 = witTypes.None[string]() + case 1: + value1533 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1534 = witTypes.Some[string](value1533) + default: + panic("unreachable") + } + + option1535 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1530, option1532, option1534}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU32Type(option1535) + + case 9: + var option1542 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1542 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1537 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1536 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1536 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1536 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1537 = witTypes.Some[golem_core_types.NumericBound](variant1536) + default: + panic("unreachable") + } + var option1539 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1538 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1538 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1538 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1539 = witTypes.Some[golem_core_types.NumericBound](variant1538) + default: + panic("unreachable") + } + var option1541 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1541 = witTypes.None[string]() + case 1: + value1540 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1541 = witTypes.Some[string](value1540) + default: + panic("unreachable") + } + + option1542 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1537, option1539, option1541}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU64Type(option1542) + + case 10: + var option1549 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1549 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1544 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1543 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1543 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1543 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1544 = witTypes.Some[golem_core_types.NumericBound](variant1543) + default: + panic("unreachable") + } + var option1546 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1545 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1545 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1545 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1546 = witTypes.Some[golem_core_types.NumericBound](variant1545) + default: + panic("unreachable") + } + var option1548 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1548 = witTypes.None[string]() + case 1: + value1547 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1548 = witTypes.Some[string](value1547) + default: + panic("unreachable") + } + + option1549 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1544, option1546, option1548}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyF32Type(option1549) + + case 11: + var option1556 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1556 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1551 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1550 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1550 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1550 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1551 = witTypes.Some[golem_core_types.NumericBound](variant1550) + default: + panic("unreachable") + } + var option1553 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1552 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1552 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1552 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1553 = witTypes.Some[golem_core_types.NumericBound](variant1552) + default: + panic("unreachable") + } + var option1555 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1555 = witTypes.None[string]() + case 1: + value1554 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1555 = witTypes.Some[string](value1554) + default: + panic("unreachable") + } + + option1556 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1551, option1553, option1555}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyF64Type(option1556) + + case 12: + + variant1650 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1650 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1569 := 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)) + value1557 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1559 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1559 = witTypes.None[string]() + case 1: + value1558 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1559 = witTypes.Some[string](value1558) + default: + panic("unreachable") + } + result1561 := 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)) + 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) + } + + result1563 := 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)) + value1562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1563 = append(result1563, value1562) + } + + var option1565 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1565 = witTypes.None[string]() + case 1: + value1564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1565 = witTypes.Some[string](value1564) + default: + panic("unreachable") + } + var option1568 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1568 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1567 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1567 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1567 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1567 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1566 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1567 = golem_core_types.MakeRoleOther(value1566) + + default: + panic("unreachable") + } + + option1568 = witTypes.Some[golem_core_types.Role](variant1567) + default: + panic("unreachable") + } + + result1569 = append(result1569, golem_core_types.NamedFieldType{value1557, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1559, result1561, result1563, option1565, option1568}}) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyRecordType(result1569) + + case 15: + result1583 := 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)) + value1570 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1571 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1571 = witTypes.None[int32]() + case 1: + + option1571 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1573 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1573 = witTypes.None[string]() + case 1: + value1572 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1573 = witTypes.Some[string](value1572) + default: + panic("unreachable") + } + result1575 := 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)) + 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) + } + + result1577 := 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)) + 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) + } + + var option1579 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1579 = witTypes.None[string]() + case 1: + value1578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1579 = witTypes.Some[string](value1578) + default: + panic("unreachable") + } + var option1582 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1582 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1581 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1581 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1581 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1581 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1580 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1581 = golem_core_types.MakeRoleOther(value1580) + + default: + panic("unreachable") + } + + option1582 = witTypes.Some[golem_core_types.Role](variant1581) + default: + panic("unreachable") + } + + result1583 = append(result1583, golem_core_types.VariantCaseType{value1570, option1571, golem_core_types.MetadataEnvelope{option1573, result1575, result1577, option1579, option1582}}) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyVariantType(result1583) + + case 16: + 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) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyEnumType(result1585) + + case 17: + result1587 := 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)) + value1586 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1587 = append(result1587, value1586) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1587) + + case 18: + result1588 := 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) + + result1588 = append(result1588, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyTupleType(result1588) + + case 19: + + variant1650 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1650 = 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: + + variant1650 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1650 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1589 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1589 = witTypes.None[int32]() + case 1: + + option1589 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1590 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1590 = witTypes.None[int32]() + case 1: + + option1590 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1589, option1590}) + + case 24: + var option1593 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1593 = witTypes.None[[]string]() + case 1: + result1592 := 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)) + value1591 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1592 = append(result1592, value1591) + } + + option1593 = witTypes.Some[[]string](result1592) + default: + panic("unreachable") + } + var option1594 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1594 = witTypes.None[uint32]() + case 1: + + option1594 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1595 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1595 = witTypes.None[uint32]() + case 1: + + option1595 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1597 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1597 = witTypes.None[string]() + case 1: + value1596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1597 = witTypes.Some[string](value1596) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1593, option1594, option1595, option1597}) + + case 25: + var option1600 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1600 = witTypes.None[[]string]() + case 1: + result1599 := 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)) + value1598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1599 = append(result1599, value1598) + } + + option1600 = witTypes.Some[[]string](result1599) + default: + panic("unreachable") + } + var option1601 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1601 = witTypes.None[uint32]() + case 1: + + option1601 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1602 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1602 = witTypes.None[uint32]() + case 1: + + option1602 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1600, option1601, option1602}) + + case 26: + var option1605 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1605 = witTypes.None[[]string]() + case 1: + result1604 := 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)) + value1603 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1604 = append(result1604, value1603) + } + + option1605 = witTypes.Some[[]string](result1604) + default: + panic("unreachable") + } + var option1608 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1608 = witTypes.None[[]string]() + case 1: + result1607 := 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)) + value1606 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1607 = append(result1607, value1606) + } + + option1608 = witTypes.Some[[]string](result1607) + default: + panic("unreachable") + } + + variant1650 = 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)))), option1605, option1608}) + + case 27: + var option1611 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1611 = witTypes.None[[]string]() + case 1: + result1610 := 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)) + value1609 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1610 = append(result1610, value1609) + } + + option1611 = witTypes.Some[[]string](result1610) + default: + panic("unreachable") + } + var option1614 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1614 = witTypes.None[[]string]() + case 1: + result1613 := 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)) + value1612 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1613 = append(result1613, value1612) + } + + option1614 = witTypes.Some[[]string](result1613) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1611, option1614}) + + case 28: + + variant1650 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1650 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1615 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1617 := 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)) + value1616 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1617 = append(result1617, value1616) + } + + var option1619 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1619 = 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))), value1618}) + default: + panic("unreachable") + } + var option1621 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1621 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1621 = 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))), value1620}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1615, result1617, option1619, option1621}) + + case 31: + result1643 := 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)) + value1622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1631 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1623 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRulePrefix(value1623) + + case 1: + value1624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleSuffix(value1624) + + case 2: + value1625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleContains(value1625) + + case 3: + value1626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleRegex(value1626) + + case 4: + value1627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1629 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1629 = witTypes.None[string]() + case 1: + value1628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1629 = witTypes.Some[string](value1628) + default: + panic("unreachable") + } + + variant1631 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1627, option1629}) + + case 5: + value1630 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1630) + + default: + panic("unreachable") + } + var option1633 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1633 = witTypes.None[string]() + case 1: + value1632 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1633 = witTypes.Some[string](value1632) + default: + panic("unreachable") + } + result1635 := 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)) + 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) + } + + result1637 := 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)) + value1636 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1637 = append(result1637, value1636) + } + + var option1639 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1639 = witTypes.None[string]() + case 1: + value1638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1639 = witTypes.Some[string](value1638) + default: + panic("unreachable") + } + var option1642 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1642 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1641 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1641 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1641 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1641 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1640 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1641 = golem_core_types.MakeRoleOther(value1640) + + default: + panic("unreachable") + } + + option1642 = witTypes.Some[golem_core_types.Role](variant1641) + default: + panic("unreachable") + } + + result1643 = append(result1643, golem_core_types.UnionBranch{value1622, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1631, golem_core_types.MetadataEnvelope{option1633, result1635, result1637, option1639, option1642}}) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1643}) + + case 32: + var option1645 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1645 = witTypes.None[string]() + case 1: + value1644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1645 = witTypes.Some[string](value1644) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1645}) + + case 33: + var option1647 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1647 = witTypes.None[string]() + case 1: + value1646 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1647 = witTypes.Some[string](value1646) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1647}) + + case 34: + + variant1650 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1648 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1648 = witTypes.None[int32]() + case 1: + + option1648 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyFutureType(option1648) + + case 36: + var option1649 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1649 = witTypes.None[int32]() + case 1: + + option1649 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyStreamType(option1649) + + default: + panic("unreachable") + } + var option1652 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1652 = witTypes.None[string]() + case 1: + value1651 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1652 = witTypes.Some[string](value1651) + default: + panic("unreachable") + } + result1654 := 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)) + 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) + } + + result1656 := 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)) + value1655 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1656 = append(result1656, value1655) + } + + var option1658 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1658 = witTypes.None[string]() + case 1: + value1657 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1658 = witTypes.Some[string](value1657) + default: + panic("unreachable") + } + var option1661 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1661 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1660 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1660 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1660 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1660 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1659 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1660 = golem_core_types.MakeRoleOther(value1659) + + default: + panic("unreachable") + } + + option1661 = witTypes.Some[golem_core_types.Role](variant1660) + default: + panic("unreachable") + } + + result1662 = append(result1662, golem_core_types.SchemaTypeNode{variant1650, golem_core_types.MetadataEnvelope{option1652, result1654, result1656, option1658, option1661}}) + } + + result1666 := 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)) + value1663 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1665 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1665 = witTypes.None[string]() + case 1: + value1664 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1665 = witTypes.Some[string](value1664) + default: + panic("unreachable") + } + + result1666 = append(result1666, golem_core_types.SchemaTypeDef{value1663, option1665, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1690 := 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 variant1689 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1689 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1689 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1689 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1689 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1689 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1689 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1689 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1689 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1689 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1689 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1689 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1689 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1667 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeStringValue(value1667) + + case 13: + result1668 := 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) + + result1668 = append(result1668, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeRecordValue(result1668) + + case 14: + var option1669 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1669 = witTypes.None[int32]() + case 1: + + option1669 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1669}) + + case 15: + + variant1689 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1670 := 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) + + result1670 = append(result1670, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1670) + + case 17: + 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))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeTupleValue(result1671) + + case 18: + result1672 := 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) + + result1672 = append(result1672, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeListValue(result1672) + + case 19: + result1673 := 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) + + result1673 = append(result1673, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1673) + + case 20: + result1674 := 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) + + result1674 = append(result1674, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeMapValue(result1674) + + case 21: + var option1675 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1675 = witTypes.None[int32]() + case 1: + + option1675 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeOptionValue(option1675) + + case 22: + var variant1678 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1676 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1676 = witTypes.None[int32]() + case 1: + + option1676 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1678 = golem_core_types.MakeResultValuePayloadOkValue(option1676) + + case 1: + var option1677 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1677 = witTypes.None[int32]() + case 1: + + option1677 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1678 = golem_core_types.MakeResultValuePayloadErrValue(option1677) + + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeResultValue(variant1678) + + case 23: + value1679 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1681 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1681 = witTypes.None[string]() + case 1: + value1680 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1681 = witTypes.Some[string](value1680) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1679, option1681}) + + case 24: + value1682 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1684 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1684 = witTypes.None[string]() + case 1: + value1683 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1684 = witTypes.Some[string](value1683) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1682, option1684}) + + case 25: + value1685 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodePathValue(value1685) + + case 26: + value1686 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeUrlValue(value1686) + + case 27: + + variant1689 = 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: + + variant1689 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1687 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1687}) + + case 30: + value1688 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1688, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1689 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1689 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1689 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1690 = append(result1690, variant1689) + } + + variant1697 = MakeAgentInvocationResultAgentMethod(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1662, result1666, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))}, golem_core_types.SchemaValueTree{result1690, *(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 8*4)))}}}) + + case 2: + + variant1697 = MakeAgentInvocationResultManualUpdate() + + case 3: + var option1692 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) { + case 0: + + option1692 = witTypes.None[string]() + case 1: + value1691 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) + + option1692 = witTypes.Some[string](value1691) + default: + panic("unreachable") + } + + variant1697 = MakeAgentInvocationResultLoadSnapshot(FallibleResultParameters{option1692}) + + case 4: + value1693 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) + value1694 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + variant1697 = MakeAgentInvocationResultSaveSnapshot(SaveSnapshotResultParameters{SnapshotData{value1693, value1694}}) + + case 5: + var option1696 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) { + case 0: + + option1696 = witTypes.None[string]() + case 1: + value1695 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) + + option1696 = witTypes.Some[string](value1695) + default: + panic("unreachable") + } + + variant1697 = MakeAgentInvocationResultProcessOplogEntries(FallibleResultParameters{option1696}) + + default: + panic("unreachable") + } + var option1699 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 9*4)))) { + case 0: + + option1699 = witTypes.None[string]() + case 1: + value1698 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 11*4)))) + + option1699 = witTypes.Some[string](value1698) + default: + panic("unreachable") + } + + variant2472 = 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)))}, variant1697, option1699, *(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 12*4))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))))}) + + case 6: + + variant2472 = 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: + value1700 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + var option1703 witTypes.Option[RetryPolicyState] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) { + case 0: + + option1703 = witTypes.None[RetryPolicyState]() + case 1: + result1702 := 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 variant1701 StateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1701 = MakeStateNodeCounter(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)))) + + case 1: + + variant1701 = MakeStateNodeTerminal() + + case 2: + + variant1701 = MakeStateNodeWrapper(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))) + + case 3: + + variant1701 = MakeStateNodeCountBox(CountBoxState{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 4: + + variant1701 = 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: + + variant1701 = MakeStateNodePair(PairState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))}) + + default: + panic("unreachable") + } + + result1702 = append(result1702, variant1701) + } + + option1703 = witTypes.Some[RetryPolicyState](RetryPolicyState{result1702}) + default: + panic("unreachable") + } + + variant2472 = 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)))}, value1700, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) != 0), option1703}) + + case 8: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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 variant2148 AgentInvocation + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + value1704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + result1880 := 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 variant1868 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1868 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1868 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1711 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1711 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1706 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1705 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1705 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1705 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1706 = witTypes.Some[golem_core_types.NumericBound](variant1705) + default: + panic("unreachable") + } + var option1708 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1707 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1707 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1707 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1708 = witTypes.Some[golem_core_types.NumericBound](variant1707) + default: + panic("unreachable") + } + var option1710 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1710 = witTypes.None[string]() + case 1: + value1709 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1710 = witTypes.Some[string](value1709) + default: + panic("unreachable") + } + + option1711 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1706, option1708, option1710}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS8Type(option1711) + + case 3: + var option1718 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1718 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1713 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1712 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1712 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1712 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1713 = witTypes.Some[golem_core_types.NumericBound](variant1712) + default: + panic("unreachable") + } + var option1715 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1714 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1714 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1714 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1715 = witTypes.Some[golem_core_types.NumericBound](variant1714) + default: + panic("unreachable") + } + var option1717 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1717 = witTypes.None[string]() + case 1: + value1716 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1717 = witTypes.Some[string](value1716) + default: + panic("unreachable") + } + + option1718 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1713, option1715, option1717}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS16Type(option1718) + + case 4: + var option1725 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1725 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1720 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1719 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1719 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1719 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1720 = witTypes.Some[golem_core_types.NumericBound](variant1719) + default: + panic("unreachable") + } + var option1722 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1721 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1721 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1721 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1722 = witTypes.Some[golem_core_types.NumericBound](variant1721) + default: + panic("unreachable") + } + var option1724 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1724 = witTypes.None[string]() + case 1: + value1723 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1724 = witTypes.Some[string](value1723) + default: + panic("unreachable") + } + + option1725 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1720, option1722, option1724}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS32Type(option1725) + + case 5: + var option1732 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1732 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1727 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1726 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1726 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1726 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1727 = witTypes.Some[golem_core_types.NumericBound](variant1726) + default: + panic("unreachable") + } + var option1729 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1728 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1728 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1728 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1729 = witTypes.Some[golem_core_types.NumericBound](variant1728) + default: + panic("unreachable") + } + var option1731 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1731 = witTypes.None[string]() + case 1: + value1730 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1731 = witTypes.Some[string](value1730) + default: + panic("unreachable") + } + + option1732 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1727, option1729, option1731}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS64Type(option1732) + + case 6: + var option1739 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1739 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1734 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1733 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1733 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1733 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1734 = witTypes.Some[golem_core_types.NumericBound](variant1733) + default: + panic("unreachable") + } + var option1736 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1735 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1735 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1735 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1736 = witTypes.Some[golem_core_types.NumericBound](variant1735) + default: + panic("unreachable") + } + var option1738 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1738 = witTypes.None[string]() + case 1: + value1737 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1738 = witTypes.Some[string](value1737) + default: + panic("unreachable") + } + + option1739 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1734, option1736, option1738}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU8Type(option1739) + + case 7: + var option1746 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1746 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1741 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1740 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1740 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1740 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1741 = witTypes.Some[golem_core_types.NumericBound](variant1740) + default: + panic("unreachable") + } + var option1743 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1742 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1742 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1742 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1743 = witTypes.Some[golem_core_types.NumericBound](variant1742) + default: + panic("unreachable") + } + var option1745 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1745 = witTypes.None[string]() + case 1: + value1744 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1745 = witTypes.Some[string](value1744) + default: + panic("unreachable") + } + + option1746 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1741, option1743, option1745}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU16Type(option1746) + + case 8: + var option1753 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1753 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1748 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1747 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1747 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1747 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1748 = witTypes.Some[golem_core_types.NumericBound](variant1747) + default: + panic("unreachable") + } + var option1750 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1749 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1749 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1749 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1750 = witTypes.Some[golem_core_types.NumericBound](variant1749) + default: + panic("unreachable") + } + var option1752 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1752 = witTypes.None[string]() + case 1: + value1751 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1752 = witTypes.Some[string](value1751) + default: + panic("unreachable") + } + + option1753 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1748, option1750, option1752}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU32Type(option1753) + + case 9: + var option1760 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1760 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1755 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1754 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1754 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1754 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1755 = witTypes.Some[golem_core_types.NumericBound](variant1754) + default: + panic("unreachable") + } + var option1757 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1756 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1756 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1756 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1757 = witTypes.Some[golem_core_types.NumericBound](variant1756) + default: + panic("unreachable") + } + var option1759 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1759 = witTypes.None[string]() + case 1: + value1758 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1759 = witTypes.Some[string](value1758) + default: + panic("unreachable") + } + + option1760 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1755, option1757, option1759}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU64Type(option1760) + + case 10: + var option1767 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1767 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1762 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1761 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1761 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1761 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1762 = witTypes.Some[golem_core_types.NumericBound](variant1761) + default: + panic("unreachable") + } + var option1764 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1763 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1763 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1763 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1764 = witTypes.Some[golem_core_types.NumericBound](variant1763) + default: + panic("unreachable") + } + var option1766 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1766 = witTypes.None[string]() + case 1: + value1765 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1766 = witTypes.Some[string](value1765) + default: + panic("unreachable") + } + + option1767 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1762, option1764, option1766}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyF32Type(option1767) + + case 11: + var option1774 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1774 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1769 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1768 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1768 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1768 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1769 = witTypes.Some[golem_core_types.NumericBound](variant1768) + default: + panic("unreachable") + } + var option1771 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1770 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1770 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1770 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1771 = witTypes.Some[golem_core_types.NumericBound](variant1770) + default: + panic("unreachable") + } + var option1773 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1773 = witTypes.None[string]() + case 1: + value1772 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1773 = witTypes.Some[string](value1772) + default: + panic("unreachable") + } + + option1774 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1769, option1771, option1773}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyF64Type(option1774) + + case 12: + + variant1868 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1868 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1787 := 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)) + value1775 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1777 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1777 = witTypes.None[string]() + case 1: + value1776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1777 = witTypes.Some[string](value1776) + default: + panic("unreachable") + } + result1779 := 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)) + 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) + } + + result1781 := 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)) + 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) + } + + var option1783 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1783 = witTypes.None[string]() + case 1: + value1782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1783 = witTypes.Some[string](value1782) + default: + panic("unreachable") + } + var option1786 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1786 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1785 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1785 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1785 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1785 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1785 = golem_core_types.MakeRoleOther(value1784) + + default: + panic("unreachable") + } + + option1786 = witTypes.Some[golem_core_types.Role](variant1785) + default: + panic("unreachable") + } + + result1787 = append(result1787, golem_core_types.NamedFieldType{value1775, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1777, result1779, result1781, option1783, option1786}}) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyRecordType(result1787) + + case 15: + result1801 := 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)) + value1788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1789 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1789 = witTypes.None[int32]() + case 1: + + option1789 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1791 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1791 = witTypes.None[string]() + case 1: + value1790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1791 = witTypes.Some[string](value1790) + default: + panic("unreachable") + } + result1793 := 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)) + 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) + } + + result1795 := 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)) + 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) + } + + var option1797 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1797 = witTypes.None[string]() + case 1: + value1796 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1797 = witTypes.Some[string](value1796) + default: + panic("unreachable") + } + var option1800 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1800 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1799 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1799 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1799 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1799 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1798 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1799 = golem_core_types.MakeRoleOther(value1798) + + default: + panic("unreachable") + } + + option1800 = witTypes.Some[golem_core_types.Role](variant1799) + default: + panic("unreachable") + } + + result1801 = append(result1801, golem_core_types.VariantCaseType{value1788, option1789, golem_core_types.MetadataEnvelope{option1791, result1793, result1795, option1797, option1800}}) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyVariantType(result1801) + + case 16: + 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) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyEnumType(result1803) + + case 17: + 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) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1805) + + case 18: + result1806 := 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) + + result1806 = append(result1806, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyTupleType(result1806) + + case 19: + + variant1868 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1868 = 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: + + variant1868 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1868 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1807 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1807 = witTypes.None[int32]() + case 1: + + option1807 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1808 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1808 = witTypes.None[int32]() + case 1: + + option1808 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1807, option1808}) + + case 24: + var option1811 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1811 = witTypes.None[[]string]() + case 1: + result1810 := 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)) + value1809 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1810 = append(result1810, value1809) + } + + option1811 = witTypes.Some[[]string](result1810) + default: + panic("unreachable") + } + var option1812 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1812 = witTypes.None[uint32]() + case 1: + + option1812 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1813 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1813 = witTypes.None[uint32]() + case 1: + + option1813 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1815 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1815 = witTypes.None[string]() + case 1: + value1814 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1815 = witTypes.Some[string](value1814) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1811, option1812, option1813, option1815}) + + case 25: + var option1818 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1818 = witTypes.None[[]string]() + case 1: + result1817 := 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)) + value1816 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1817 = append(result1817, value1816) + } + + option1818 = witTypes.Some[[]string](result1817) + default: + panic("unreachable") + } + var option1819 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1819 = witTypes.None[uint32]() + case 1: + + option1819 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1820 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1820 = witTypes.None[uint32]() + case 1: + + option1820 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1818, option1819, option1820}) + + case 26: + var option1823 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1823 = witTypes.None[[]string]() + case 1: + result1822 := 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)) + value1821 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1822 = append(result1822, value1821) + } + + option1823 = witTypes.Some[[]string](result1822) + default: + panic("unreachable") + } + var option1826 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1826 = witTypes.None[[]string]() + case 1: + result1825 := 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)) + value1824 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1825 = append(result1825, value1824) + } + + option1826 = witTypes.Some[[]string](result1825) + default: + panic("unreachable") + } + + variant1868 = 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)))), option1823, option1826}) + + case 27: + var option1829 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1829 = witTypes.None[[]string]() + case 1: + result1828 := 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)) + value1827 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1828 = append(result1828, value1827) + } + + option1829 = witTypes.Some[[]string](result1828) + default: + panic("unreachable") + } + var option1832 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1832 = witTypes.None[[]string]() + case 1: + result1831 := 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)) + value1830 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1831 = append(result1831, value1830) + } + + option1832 = witTypes.Some[[]string](result1831) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1829, option1832}) + + case 28: + + variant1868 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1868 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1833 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1835 := 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)) + value1834 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1835 = append(result1835, value1834) + } + + var option1837 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1837 = 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))), value1836}) + default: + panic("unreachable") + } + var option1839 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*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), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1839 = 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))), value1838}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1833, result1835, option1837, option1839}) + + case 31: + result1861 := 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)) + value1840 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1849 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1841 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRulePrefix(value1841) + + case 1: + value1842 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleSuffix(value1842) + + case 2: + value1843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleContains(value1843) + + case 3: + value1844 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleRegex(value1844) + + case 4: + value1845 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1847 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1847 = witTypes.None[string]() + case 1: + value1846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1847 = witTypes.Some[string](value1846) + default: + panic("unreachable") + } + + variant1849 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1845, option1847}) + + case 5: + value1848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1848) + + default: + panic("unreachable") + } + var option1851 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1851 = witTypes.None[string]() + case 1: + value1850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1851 = witTypes.Some[string](value1850) + default: + panic("unreachable") + } + result1853 := 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)) + 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) + } + + result1855 := 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)) + 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) + } + + var option1857 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1857 = witTypes.None[string]() + case 1: + value1856 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1857 = witTypes.Some[string](value1856) + default: + panic("unreachable") + } + var option1860 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1860 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1859 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1859 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1859 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1859 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1858 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1859 = golem_core_types.MakeRoleOther(value1858) + + default: + panic("unreachable") + } + + option1860 = witTypes.Some[golem_core_types.Role](variant1859) + default: + panic("unreachable") + } + + result1861 = append(result1861, golem_core_types.UnionBranch{value1840, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1849, golem_core_types.MetadataEnvelope{option1851, result1853, result1855, option1857, option1860}}) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1861}) + + case 32: + var option1863 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1863 = witTypes.None[string]() + case 1: + value1862 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1863 = witTypes.Some[string](value1862) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1863}) + + case 33: + var option1865 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1865 = witTypes.None[string]() + case 1: + value1864 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1865 = witTypes.Some[string](value1864) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1865}) + + case 34: + + variant1868 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1866 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1866 = witTypes.None[int32]() + case 1: + + option1866 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyFutureType(option1866) + + case 36: + var option1867 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1867 = witTypes.None[int32]() + case 1: + + option1867 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyStreamType(option1867) + + default: + panic("unreachable") + } + var option1870 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1870 = witTypes.None[string]() + case 1: + value1869 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1870 = witTypes.Some[string](value1869) + default: + panic("unreachable") + } + result1872 := 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)) + 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) + } + + result1874 := 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)) + 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) + } + + var option1876 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1876 = witTypes.None[string]() + case 1: + value1875 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1876 = witTypes.Some[string](value1875) + default: + panic("unreachable") + } + var option1879 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1879 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1878 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1878 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1878 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1878 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1877 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1878 = golem_core_types.MakeRoleOther(value1877) + + default: + panic("unreachable") + } + + option1879 = witTypes.Some[golem_core_types.Role](variant1878) + default: + panic("unreachable") + } + + result1880 = append(result1880, golem_core_types.SchemaTypeNode{variant1868, golem_core_types.MetadataEnvelope{option1870, result1872, result1874, option1876, option1879}}) + } + + result1884 := 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)) + value1881 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1883 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1883 = witTypes.None[string]() + case 1: + value1882 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1883 = witTypes.Some[string](value1882) + default: + panic("unreachable") + } + + result1884 = append(result1884, golem_core_types.SchemaTypeDef{value1881, option1883, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1908 := 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 variant1907 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1907 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1907 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1907 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1907 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1907 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1907 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1907 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1907 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1907 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1907 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1907 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1907 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1885 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeStringValue(value1885) + + case 13: + result1886 := 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) + + result1886 = append(result1886, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeRecordValue(result1886) + + case 14: + var option1887 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1887 = witTypes.None[int32]() + case 1: + + option1887 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1887}) + + case 15: + + variant1907 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1888 := 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) + + result1888 = append(result1888, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1888) + + case 17: + 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))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeTupleValue(result1889) + + case 18: + result1890 := 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) + + result1890 = append(result1890, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeListValue(result1890) + + case 19: + 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))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1891) + + case 20: + result1892 := 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) + + result1892 = append(result1892, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeMapValue(result1892) + + case 21: + var option1893 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1893 = witTypes.None[int32]() + case 1: + + option1893 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeOptionValue(option1893) + + case 22: + var variant1896 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1894 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1894 = witTypes.None[int32]() + case 1: + + option1894 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1896 = golem_core_types.MakeResultValuePayloadOkValue(option1894) + + case 1: + var option1895 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1895 = witTypes.None[int32]() + case 1: + + option1895 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1896 = golem_core_types.MakeResultValuePayloadErrValue(option1895) + + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeResultValue(variant1896) + + case 23: + value1897 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1899 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1899 = witTypes.None[string]() + case 1: + value1898 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1899 = witTypes.Some[string](value1898) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1897, option1899}) + + case 24: + value1900 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1902 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1902 = witTypes.None[string]() + case 1: + value1901 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1902 = witTypes.Some[string](value1901) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1900, option1902}) + + case 25: + value1903 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodePathValue(value1903) + + case 26: + value1904 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeUrlValue(value1904) + + case 27: + + variant1907 = 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: + + variant1907 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1905 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1905}) + + case 30: + value1906 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1906, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1907 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1907 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1907 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1908 = append(result1908, variant1907) + } + + value1909 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))) + result1911 := 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)) + value1910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1911 = append(result1911, value1910) + } + + result1923 := 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)) + result1922 := 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 variant1921 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1912 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1914 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1914 = witTypes.None[string]() + case 1: + value1913 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1914 = witTypes.Some[string](value1913) + default: + panic("unreachable") + } + var option1915 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1915 = witTypes.None[uint64]() + case 1: + + option1915 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1919 := 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)) + value1916 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1918 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1917 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1918 = golem_api_context.MakeAttributeValueString(value1917) + + default: + panic("unreachable") + } + + result1919 = append(result1919, golem_api_context.Attribute{value1916, variant1918}) + } + + variant1921 = MakeSpanDataLocalSpan(LocalSpanData{value1912, 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))))}, option1914, option1915, result1919, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1920 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1921 = MakeSpanDataExternalSpan(ExternalSpanData{value1920}) + + default: + panic("unreachable") + } + + result1922 = append(result1922, variant1921) + } + + result1923 = append(result1923, result1922) + } + + variant2148 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1704, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1880, result1884, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))}, golem_core_types.SchemaValueTree{result1908, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))}}, value1909, result1911, result1923}) + + case 1: + value1924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value1925 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + result2101 := 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 variant2089 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2089 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant2089 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1932 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1932 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1927 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1926 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1926 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1926 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1927 = witTypes.Some[golem_core_types.NumericBound](variant1926) + default: + panic("unreachable") + } + var option1929 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1929 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1928 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1928 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1928 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1928 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1929 = witTypes.Some[golem_core_types.NumericBound](variant1928) + default: + panic("unreachable") + } + var option1931 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1931 = witTypes.None[string]() + case 1: + value1930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1931 = witTypes.Some[string](value1930) + default: + panic("unreachable") + } + + option1932 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1927, option1929, option1931}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS8Type(option1932) + + case 3: + var option1939 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1939 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1934 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1933 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1933 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1933 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1934 = witTypes.Some[golem_core_types.NumericBound](variant1933) + default: + panic("unreachable") + } + var option1936 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1936 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1935 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1935 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1935 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1935 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1936 = witTypes.Some[golem_core_types.NumericBound](variant1935) + default: + panic("unreachable") + } + var option1938 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1938 = witTypes.None[string]() + case 1: + value1937 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1938 = witTypes.Some[string](value1937) + default: + panic("unreachable") + } + + option1939 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1934, option1936, option1938}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS16Type(option1939) + + case 4: + var option1946 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1946 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1941 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1940 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1940 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1940 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1941 = witTypes.Some[golem_core_types.NumericBound](variant1940) + default: + panic("unreachable") + } + var option1943 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1943 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1942 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1942 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1942 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1942 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1943 = witTypes.Some[golem_core_types.NumericBound](variant1942) + default: + panic("unreachable") + } + var option1945 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1945 = witTypes.None[string]() + case 1: + value1944 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1945 = witTypes.Some[string](value1944) + default: + panic("unreachable") + } + + option1946 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1941, option1943, option1945}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS32Type(option1946) + + case 5: + var option1953 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1953 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1948 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1947 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1947 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1947 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1948 = witTypes.Some[golem_core_types.NumericBound](variant1947) + default: + panic("unreachable") + } + var option1950 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1950 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1949 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1949 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1949 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1949 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1950 = witTypes.Some[golem_core_types.NumericBound](variant1949) + default: + panic("unreachable") + } + var option1952 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1952 = witTypes.None[string]() + case 1: + value1951 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1952 = witTypes.Some[string](value1951) + default: + panic("unreachable") + } + + option1953 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1948, option1950, option1952}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS64Type(option1953) + + case 6: + var option1960 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1960 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1955 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1954 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1954 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1954 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1955 = witTypes.Some[golem_core_types.NumericBound](variant1954) + default: + panic("unreachable") + } + var option1957 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1957 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1956 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1956 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1956 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1956 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1957 = witTypes.Some[golem_core_types.NumericBound](variant1956) + default: + panic("unreachable") + } + var option1959 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1959 = witTypes.None[string]() + case 1: + value1958 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1959 = witTypes.Some[string](value1958) + default: + panic("unreachable") + } + + option1960 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1955, option1957, option1959}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU8Type(option1960) + + case 7: + var option1967 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1967 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1962 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1961 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1961 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1961 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1962 = witTypes.Some[golem_core_types.NumericBound](variant1961) + default: + panic("unreachable") + } + var option1964 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1964 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1963 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1963 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1963 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1963 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1964 = witTypes.Some[golem_core_types.NumericBound](variant1963) + default: + panic("unreachable") + } + var option1966 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1966 = witTypes.None[string]() + case 1: + value1965 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1966 = witTypes.Some[string](value1965) + default: + panic("unreachable") + } + + option1967 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1962, option1964, option1966}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU16Type(option1967) + + case 8: + var option1974 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1974 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1969 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1968 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1968 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1968 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1969 = witTypes.Some[golem_core_types.NumericBound](variant1968) + default: + panic("unreachable") + } + var option1971 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1971 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1970 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1970 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1970 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1970 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1971 = witTypes.Some[golem_core_types.NumericBound](variant1970) + default: + panic("unreachable") + } + var option1973 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1973 = witTypes.None[string]() + case 1: + value1972 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1973 = witTypes.Some[string](value1972) + default: + panic("unreachable") + } + + option1974 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1969, option1971, option1973}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU32Type(option1974) + + case 9: + var option1981 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1981 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1976 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1975 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1975 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1975 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1976 = witTypes.Some[golem_core_types.NumericBound](variant1975) + default: + panic("unreachable") + } + var option1978 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1978 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1977 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1977 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1977 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1977 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1978 = witTypes.Some[golem_core_types.NumericBound](variant1977) + default: + panic("unreachable") + } + var option1980 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1980 = witTypes.None[string]() + case 1: + value1979 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1980 = witTypes.Some[string](value1979) + default: + panic("unreachable") + } + + option1981 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1976, option1978, option1980}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU64Type(option1981) + + case 10: + var option1988 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1988 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1983 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1982 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1982 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1982 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1983 = witTypes.Some[golem_core_types.NumericBound](variant1982) + default: + panic("unreachable") + } + var option1985 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1985 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1984 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1984 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1984 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1984 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1985 = witTypes.Some[golem_core_types.NumericBound](variant1984) + default: + panic("unreachable") + } + var option1987 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1987 = witTypes.None[string]() + case 1: + value1986 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1987 = witTypes.Some[string](value1986) + default: + panic("unreachable") + } + + option1988 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1983, option1985, option1987}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyF32Type(option1988) + + case 11: + var option1995 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1995 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1990 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1989 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1989 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1989 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1990 = witTypes.Some[golem_core_types.NumericBound](variant1989) + default: + panic("unreachable") + } + var option1992 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1992 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1991 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1991 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1991 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1991 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1992 = witTypes.Some[golem_core_types.NumericBound](variant1991) + default: + panic("unreachable") + } + var option1994 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1994 = witTypes.None[string]() + case 1: + value1993 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1994 = witTypes.Some[string](value1993) + default: + panic("unreachable") + } + + option1995 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1990, option1992, option1994}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyF64Type(option1995) + + case 12: + + variant2089 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant2089 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result2008 := 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)) + value1996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1998 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1998 = witTypes.None[string]() + case 1: + value1997 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1998 = witTypes.Some[string](value1997) + default: + panic("unreachable") + } + result2000 := 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)) + 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) + } + + result2002 := 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)) + value2001 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2002 = append(result2002, value2001) + } + + var option2004 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option2004 = witTypes.None[string]() + case 1: + value2003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option2004 = witTypes.Some[string](value2003) + default: + panic("unreachable") + } + var option2007 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option2007 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2006 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant2006 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2006 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2006 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2005 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant2006 = golem_core_types.MakeRoleOther(value2005) + + default: + panic("unreachable") + } + + option2007 = witTypes.Some[golem_core_types.Role](variant2006) + default: + panic("unreachable") + } + + result2008 = append(result2008, golem_core_types.NamedFieldType{value1996, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1998, result2000, result2002, option2004, option2007}}) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyRecordType(result2008) + + case 15: + result2022 := 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)) + value2009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2010 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2010 = witTypes.None[int32]() + case 1: + + option2010 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option2012 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2012 = witTypes.None[string]() + case 1: + value2011 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2012 = witTypes.Some[string](value2011) + default: + panic("unreachable") + } + result2014 := 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)) + 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) + } + + result2016 := 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)) + value2015 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2016 = append(result2016, value2015) + } + + var option2018 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option2018 = witTypes.None[string]() + case 1: + value2017 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option2018 = witTypes.Some[string](value2017) + default: + panic("unreachable") + } + var option2021 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option2021 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2020 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant2020 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2020 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2020 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2019 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant2020 = golem_core_types.MakeRoleOther(value2019) + + default: + panic("unreachable") + } + + option2021 = witTypes.Some[golem_core_types.Role](variant2020) + default: + panic("unreachable") + } + + result2022 = append(result2022, golem_core_types.VariantCaseType{value2009, option2010, golem_core_types.MetadataEnvelope{option2012, result2014, result2016, option2018, option2021}}) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyVariantType(result2022) + + case 16: + 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) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyEnumType(result2024) + + case 17: + result2026 := 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)) + value2025 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2026 = append(result2026, value2025) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2026) + + case 18: + result2027 := 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) + + result2027 = append(result2027, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyTupleType(result2027) + + case 19: + + variant2089 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant2089 = 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: + + variant2089 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant2089 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option2028 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2028 = witTypes.None[int32]() + case 1: + + option2028 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option2029 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2029 = witTypes.None[int32]() + case 1: + + option2029 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2028, option2029}) + + case 24: + var option2032 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2032 = witTypes.None[[]string]() + case 1: + result2031 := 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)) + value2030 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2031 = append(result2031, value2030) + } + + option2032 = witTypes.Some[[]string](result2031) + default: + panic("unreachable") + } + var option2033 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2033 = witTypes.None[uint32]() + case 1: + + option2033 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2034 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2034 = witTypes.None[uint32]() + case 1: + + option2034 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option2036 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option2036 = witTypes.None[string]() + case 1: + value2035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option2036 = witTypes.Some[string](value2035) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2032, option2033, option2034, option2036}) + + case 25: + var option2039 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2039 = witTypes.None[[]string]() + case 1: + result2038 := 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)) + value2037 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2038 = append(result2038, value2037) + } + + option2039 = witTypes.Some[[]string](result2038) + default: + panic("unreachable") + } + var option2040 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2040 = witTypes.None[uint32]() + case 1: + + option2040 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2041 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2041 = witTypes.None[uint32]() + case 1: + + option2041 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2039, option2040, option2041}) + + case 26: + var option2044 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2044 = witTypes.None[[]string]() + case 1: + result2043 := 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)) + value2042 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2043 = append(result2043, value2042) + } + + option2044 = witTypes.Some[[]string](result2043) + default: + panic("unreachable") + } + var option2047 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2047 = witTypes.None[[]string]() + case 1: + result2046 := 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)) + value2045 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2046 = append(result2046, value2045) + } + + option2047 = witTypes.Some[[]string](result2046) + default: + panic("unreachable") + } + + variant2089 = 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)))), option2044, option2047}) + + case 27: + var option2050 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2050 = witTypes.None[[]string]() + case 1: + result2049 := 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)) + value2048 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2049 = append(result2049, value2048) + } + + option2050 = witTypes.Some[[]string](result2049) + default: + panic("unreachable") + } + var option2053 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2053 = witTypes.None[[]string]() + case 1: + result2052 := 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)) + value2051 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2052 = append(result2052, value2051) + } + + option2053 = witTypes.Some[[]string](result2052) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2050, option2053}) + + case 28: + + variant2089 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant2089 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value2054 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2056 := 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)) + value2055 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2056 = append(result2056, value2055) + } + + var option2058 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option2058 = 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))), value2057}) + default: + panic("unreachable") + } + var option2060 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option2060 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2059 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option2060 = 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))), value2059}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2054, result2056, option2058, option2060}) + + case 31: + result2082 := 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)) + value2061 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2070 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value2062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRulePrefix(value2062) + + case 1: + value2063 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleSuffix(value2063) + + case 2: + value2064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleContains(value2064) + + case 3: + value2065 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleRegex(value2065) + + case 4: + value2066 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option2068 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option2068 = witTypes.None[string]() + case 1: + value2067 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option2068 = witTypes.Some[string](value2067) + default: + panic("unreachable") + } + + variant2070 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2066, option2068}) + + case 5: + value2069 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2069) + + default: + panic("unreachable") + } + var option2072 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option2072 = witTypes.None[string]() + case 1: + value2071 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option2072 = witTypes.Some[string](value2071) + default: + panic("unreachable") + } + result2074 := 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)) + 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) + } + + result2076 := 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)) + value2075 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2076 = append(result2076, value2075) + } + + var option2078 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option2078 = witTypes.None[string]() + case 1: + value2077 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option2078 = witTypes.Some[string](value2077) + default: + panic("unreachable") + } + var option2081 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option2081 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2080 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant2080 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2080 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2080 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2079 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant2080 = golem_core_types.MakeRoleOther(value2079) + + default: + panic("unreachable") + } + + option2081 = witTypes.Some[golem_core_types.Role](variant2080) + default: + panic("unreachable") + } + + result2082 = append(result2082, golem_core_types.UnionBranch{value2061, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2070, golem_core_types.MetadataEnvelope{option2072, result2074, result2076, option2078, option2081}}) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2082}) + + case 32: + var option2084 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2084 = witTypes.None[string]() + case 1: + value2083 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option2084 = witTypes.Some[string](value2083) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2084}) + + case 33: + var option2086 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2086 = witTypes.None[string]() + case 1: + value2085 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option2086 = witTypes.Some[string](value2085) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2086}) + + case 34: + + variant2089 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyFutureType(option2087) + + case 36: + var option2088 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2088 = witTypes.None[int32]() + case 1: + + option2088 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyStreamType(option2088) + + default: + panic("unreachable") + } + var option2091 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option2091 = witTypes.None[string]() + case 1: + value2090 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option2091 = witTypes.Some[string](value2090) + default: + panic("unreachable") + } + result2093 := 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)) + 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) + } + + result2095 := 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)) + value2094 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2095 = append(result2095, value2094) + } + + var option2097 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option2097 = witTypes.None[string]() + case 1: + value2096 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option2097 = witTypes.Some[string](value2096) + default: + panic("unreachable") + } + var option2100 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option2100 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2099 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant2099 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2099 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2099 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2098 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant2099 = golem_core_types.MakeRoleOther(value2098) + + default: + panic("unreachable") + } + + option2100 = witTypes.Some[golem_core_types.Role](variant2099) + default: + panic("unreachable") + } + + result2101 = append(result2101, golem_core_types.SchemaTypeNode{variant2089, golem_core_types.MetadataEnvelope{option2091, result2093, result2095, option2097, option2100}}) + } + + result2105 := 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)) + value2102 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2104 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2104 = witTypes.None[string]() + case 1: + value2103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option2104 = witTypes.Some[string](value2103) + default: + panic("unreachable") + } + + result2105 = append(result2105, golem_core_types.SchemaTypeDef{value2102, option2104, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result2129 := 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 variant2128 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2128 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant2128 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant2128 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant2128 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant2128 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant2128 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant2128 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant2128 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant2128 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant2128 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant2128 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant2128 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value2106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeStringValue(value2106) + + case 13: + result2107 := 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) + + result2107 = append(result2107, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeRecordValue(result2107) + + case 14: + var option2108 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2108 = witTypes.None[int32]() + case 1: + + option2108 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2108}) + + case 15: + + variant2128 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result2109 := 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) + + result2109 = append(result2109, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2109) + + case 17: + 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))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeTupleValue(result2110) + + case 18: + 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))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeListValue(result2111) + + case 19: + result2112 := 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) + + result2112 = append(result2112, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2112) + + case 20: + result2113 := 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) + + result2113 = append(result2113, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeMapValue(result2113) + + case 21: + var option2114 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2114 = witTypes.None[int32]() + case 1: + + option2114 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeOptionValue(option2114) + + case 22: + var variant2117 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant2117 = golem_core_types.MakeResultValuePayloadOkValue(option2115) + + case 1: + var option2116 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2116 = witTypes.None[int32]() + case 1: + + option2116 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2117 = golem_core_types.MakeResultValuePayloadErrValue(option2116) + + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeResultValue(variant2117) + + case 23: + value2118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2120 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2120 = witTypes.None[string]() + case 1: + value2119 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2120 = witTypes.Some[string](value2119) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2118, option2120}) + + case 24: + value2121 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2123 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2123 = witTypes.None[string]() + case 1: + value2122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2123 = witTypes.Some[string](value2122) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2121, option2123}) + + case 25: + value2124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodePathValue(value2124) + + case 26: + value2125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeUrlValue(value2125) + + case 27: + + variant2128 = 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: + + variant2128 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value2126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2126}) + + case 30: + value2127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2127, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant2128 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant2128 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant2128 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result2129 = append(result2129, variant2128) + } + + value2130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 13*4)))) + result2132 := 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)) + value2131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2132 = append(result2132, value2131) + } + + result2144 := 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)) + result2143 := 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 variant2142 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2135 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option2135 = witTypes.None[string]() + case 1: + value2134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option2135 = witTypes.Some[string](value2134) + default: + panic("unreachable") + } + var option2136 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option2136 = witTypes.None[uint64]() + case 1: + + option2136 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result2140 := 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)) + value2137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2139 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value2138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant2139 = golem_api_context.MakeAttributeValueString(value2138) + + default: + panic("unreachable") + } + + result2140 = append(result2140, golem_api_context.Attribute{value2137, variant2139}) + } + + variant2142 = MakeSpanDataLocalSpan(LocalSpanData{value2133, 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))))}, option2135, option2136, result2140, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value2141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2142 = MakeSpanDataExternalSpan(ExternalSpanData{value2141}) + + default: + panic("unreachable") + } + + result2143 = append(result2143, variant2142) + } + + result2144 = append(result2144, result2143) + } + + variant2148 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1924, value1925, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2101, result2105, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}, golem_core_types.SchemaValueTree{result2129, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))}}, value2130, result2132, result2144}) + + case 2: + + variant2148 = MakeAgentInvocationSaveSnapshot() + + case 3: + value2145 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value2146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + variant2148 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value2145, value2146}}) + + case 4: + value2147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant2148 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value2147}) + + case 5: + + variant2148 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))}) + + default: + panic("unreachable") + } + + variant2472 = 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)))}, variant2148}) + + case 15: + var variant2151 UpdateDescription + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + variant2151 = MakeUpdateDescriptionAutoUpdate() + + case 1: + value2149 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) + value2150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) + + variant2151 = MakeUpdateDescriptionSnapshotBased(golem_api_host.Snapshot{value2149, value2150}) + + default: + panic("unreachable") + } + + variant2472 = 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))), variant2151}) + + case 16: + result2157 := 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)) + value2152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + value2153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4)))) + result2156 := 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)) + value2154 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2156 = append(result2156, witTypes.Tuple2[string, string]{value2154, value2155}) + } + + result2157 = append(result2157, 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)), value2152, value2153, result2156}) + } + + variant2472 = 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))), result2157}) + + case 17: + var option2159 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + option2159 = witTypes.None[string]() + case 1: + value2158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) + + option2159 = witTypes.Some[string](value2158) + default: + panic("unreachable") + } + + variant2472 = 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))), option2159}) + + case 18: + + variant2472 = 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: + + variant2472 = 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: + 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)))) + + variant2472 = 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))), value2160, value2161}) + + case 21: + value2162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value2163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + variant2472 = 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))), value2162, value2163}) + + case 22: + value2164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) + value2165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + variant2472 = 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)))), value2164, value2165}) + + case 23: + + variant2472 = 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: + value2166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + value2167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))) + result2170 := 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)) + value2168 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2170 = append(result2170, witTypes.Tuple2[string, string]{value2168, value2169}) + } + + variant2472 = 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)), value2166, value2167, result2170}}) + + case 25: + value2171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + value2172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))) + result2175 := 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)) + value2173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2175 = append(result2175, witTypes.Tuple2[string, string]{value2173, value2174}) + } + + variant2472 = 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)), value2171, value2172, result2175}}) + + case 26: + + variant2472 = 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: + value2176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2472 = 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)))}, value2176}) + + case 28: + value2177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + var option2179 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option2179 = witTypes.None[string]() + case 1: + value2178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option2179 = witTypes.Some[string](value2178) + default: + panic("unreachable") + } + var option2181 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) { + case 0: + + option2181 = witTypes.None[string]() + case 1: + value2180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 7*4)))) + + option2181 = witTypes.Some[string](value2180) + default: + panic("unreachable") + } + result2185 := 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)) + value2182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2184 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value2183 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant2184 = golem_api_context.MakeAttributeValueString(value2183) + + default: + panic("unreachable") + } + + result2185 = append(result2185, golem_api_context.Attribute{value2182, variant2184}) + } + + variant2472 = 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)))}, value2177, option2179, option2181, result2185}) + + case 29: + value2186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2472 = 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)))}, value2186}) + + case 30: + value2187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + value2188 := 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 variant2190 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) { + case 0: + value2189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + variant2190 = golem_api_context.MakeAttributeValueString(value2189) + + default: + panic("unreachable") + } + + variant2472 = 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)))}, value2187, value2188, variant2190}) + + case 31: + value2191 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2472 = 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)))}, value2191}) + + case 32: + + variant2472 = 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 33: + + variant2472 = 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 34: + + variant2472 = 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 35: + + variant2472 = 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 36: + value2192 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + value2193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) + + variant2472 = 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{value2192, value2193}}) + + case 37: + value2194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + value2195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))) + result2198 := 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)) + value2196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2198 = append(result2198, witTypes.Tuple2[string, string]{value2196, value2197}) + } + + value2199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 7*4)))) + + variant2472 = 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)), value2194, value2195, result2198}, 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))))}}, value2199}, 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 38: + value2200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + result2231 := 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 variant2230 golem_api_retry.PredicateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2203 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2203 = golem_api_retry.MakePredicateValueText(value2202) + + case 1: + + variant2203 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2203 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2201, variant2203}) + + case 1: + value2204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2206 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2206 = golem_api_retry.MakePredicateValueText(value2205) + + case 1: + + variant2206 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2206 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2204, variant2206}) + + case 2: + value2207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2209 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2209 = golem_api_retry.MakePredicateValueText(value2208) + + case 1: + + variant2209 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2209 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2207, variant2209}) + + case 3: + value2210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2212 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2212 = golem_api_retry.MakePredicateValueText(value2211) + + case 1: + + variant2212 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2212 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2210, variant2212}) + + case 4: + value2213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2215 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2214 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2215 = golem_api_retry.MakePredicateValueText(value2214) + + case 1: + + variant2215 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2215 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2213, variant2215}) + + case 5: + value2216 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2218 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2218 = golem_api_retry.MakePredicateValueText(value2217) + + case 1: + + variant2218 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2218 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2216, variant2218}) + + case 6: + value2219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropExists(value2219) + + case 7: + value2220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2223 := 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 variant2222 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2221 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2222 = golem_api_retry.MakePredicateValueText(value2221) + + case 1: + + variant2222 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 2: + + variant2222 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + default: + panic("unreachable") + } + + result2223 = append(result2223, variant2222) + } + + variant2230 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2220, result2223}) + + case 8: + value2224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2224, value2225}) + + case 9: + value2226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2226, value2227}) + + case 10: + value2228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2228, value2229}) + + case 11: + + variant2230 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2230 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2230 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 14: + + variant2230 = golem_api_retry.MakePredicateNodePredTrue() + + case 15: + + variant2230 = golem_api_retry.MakePredicateNodePredFalse() + + default: + panic("unreachable") + } + + result2231 = append(result2231, variant2230) + } + + result2264 := 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 variant2263 golem_api_retry.PolicyNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2263 = golem_api_retry.MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 1: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = golem_api_retry.MakePolicyNodeImmediate() + + case 4: + + variant2263 = golem_api_retry.MakePolicyNodeNever() + + case 5: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = golem_api_retry.MakePolicyNodeJitter(golem_api_retry.JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))}) + + case 10: + result2262 := 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 variant2261 golem_api_retry.PredicateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2234 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2234 = golem_api_retry.MakePredicateValueText(value2233) + + case 1: + + variant2234 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2234 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2232, variant2234}) + + case 1: + value2235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2237 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2237 = golem_api_retry.MakePredicateValueText(value2236) + + case 1: + + variant2237 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2237 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2235, variant2237}) + + case 2: + value2238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2240 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2240 = golem_api_retry.MakePredicateValueText(value2239) + + case 1: + + variant2240 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2240 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2238, variant2240}) + + case 3: + value2241 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2243 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2242 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2243 = golem_api_retry.MakePredicateValueText(value2242) + + case 1: + + variant2243 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2243 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2241, variant2243}) + + case 4: + value2244 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2246 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2245 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2246 = golem_api_retry.MakePredicateValueText(value2245) + + case 1: + + variant2246 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2246 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2244, variant2246}) + + case 5: + value2247 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2249 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2248 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2249 = golem_api_retry.MakePredicateValueText(value2248) + + case 1: + + variant2249 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2249 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2247, variant2249}) + + case 6: + value2250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropExists(value2250) + + case 7: + value2251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2254 := 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 variant2253 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2253 = golem_api_retry.MakePredicateValueText(value2252) + + case 1: + + variant2253 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 2: + + variant2253 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + default: + panic("unreachable") + } + + result2254 = append(result2254, variant2253) + } + + variant2261 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2251, result2254}) + + case 8: + value2255 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2255, value2256}) + + case 9: + value2257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2257, value2258}) + + case 10: + value2259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2259, value2260}) + + case 11: + + variant2261 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2261 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2261 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 14: + + variant2261 = golem_api_retry.MakePredicateNodePredTrue() + + case 15: + + variant2261 = golem_api_retry.MakePredicateNodePredFalse() + + default: + panic("unreachable") + } + + result2262 = append(result2262, variant2261) + } + + variant2263 = golem_api_retry.MakePolicyNodeFilteredOn(golem_api_retry.FilteredConfig{golem_api_retry.RetryPredicate{result2262}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 11: + + variant2263 = golem_api_retry.MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2263 = golem_api_retry.MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2263 = 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") + } + + result2264 = append(result2264, variant2263) + } + + variant2472 = 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{value2200, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))), golem_api_retry.RetryPredicate{result2231}, golem_api_retry.RetryPolicy{result2264}}}) + + case 39: + value2265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 1*4)))) + + variant2472 = 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)))}, value2265}) + + case 40: + var variant2266 QueuedCardEvent + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2266 = 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: + + variant2266 = 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") + } + + variant2472 = 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)))}, variant2266}) + + case 41: + var option2267 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + option2267 = witTypes.None[uint64]() + case 1: + + option2267 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + default: + panic("unreachable") + } + + variant2472 = 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)))}, option2267, 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 42: + + variant2472 = 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 43: + + variant2472 = 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 44: + + variant2472 = 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 45: + result2443 := 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 variant2431 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2431 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant2431 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option2274 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2274 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2269 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2269 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2268 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2268 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2268 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2268 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2269 = witTypes.Some[golem_core_types.NumericBound](variant2268) + default: + panic("unreachable") + } + var option2271 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2271 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2270 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2270 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2270 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2270 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2271 = witTypes.Some[golem_core_types.NumericBound](variant2270) + default: + panic("unreachable") + } + var option2273 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2273 = witTypes.None[string]() + case 1: + value2272 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2273 = witTypes.Some[string](value2272) + default: + panic("unreachable") + } + + option2274 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2269, option2271, option2273}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS8Type(option2274) + + case 3: + var option2281 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2281 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2276 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2276 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2275 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2275 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2275 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2275 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2276 = witTypes.Some[golem_core_types.NumericBound](variant2275) + default: + panic("unreachable") + } + var option2278 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2278 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2277 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2277 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2277 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2277 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2278 = witTypes.Some[golem_core_types.NumericBound](variant2277) + default: + panic("unreachable") + } + var option2280 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2280 = witTypes.None[string]() + case 1: + value2279 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2280 = witTypes.Some[string](value2279) + default: + panic("unreachable") + } + + option2281 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2276, option2278, option2280}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS16Type(option2281) + + case 4: + var option2288 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2288 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2283 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2283 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2282 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2282 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2282 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2282 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2283 = witTypes.Some[golem_core_types.NumericBound](variant2282) + default: + panic("unreachable") + } + var option2285 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2285 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2284 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2284 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2284 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2284 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2285 = witTypes.Some[golem_core_types.NumericBound](variant2284) + default: + panic("unreachable") + } + var option2287 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2287 = witTypes.None[string]() + case 1: + value2286 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2287 = witTypes.Some[string](value2286) + default: + panic("unreachable") + } + + option2288 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2283, option2285, option2287}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS32Type(option2288) + + case 5: + var option2295 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2295 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2290 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2290 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2289 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2289 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2289 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2289 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2290 = witTypes.Some[golem_core_types.NumericBound](variant2289) + default: + panic("unreachable") + } + var option2292 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2292 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2291 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2291 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2291 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2291 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2292 = witTypes.Some[golem_core_types.NumericBound](variant2291) + default: + panic("unreachable") + } + var option2294 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2294 = witTypes.None[string]() + case 1: + value2293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2294 = witTypes.Some[string](value2293) + default: + panic("unreachable") + } + + option2295 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2290, option2292, option2294}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS64Type(option2295) + + case 6: + var option2302 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2302 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2297 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2297 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2296 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2296 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2296 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2296 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2297 = witTypes.Some[golem_core_types.NumericBound](variant2296) + default: + panic("unreachable") + } + var option2299 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2299 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2298 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2298 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2298 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2298 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2299 = witTypes.Some[golem_core_types.NumericBound](variant2298) + default: + panic("unreachable") + } + var option2301 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2301 = witTypes.None[string]() + case 1: + value2300 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2301 = witTypes.Some[string](value2300) + default: + panic("unreachable") + } + + option2302 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2297, option2299, option2301}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU8Type(option2302) + + case 7: + var option2309 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2309 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2304 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2304 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2303 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2303 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2303 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2303 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2304 = witTypes.Some[golem_core_types.NumericBound](variant2303) + default: + panic("unreachable") + } + var option2306 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2306 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2305 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2305 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2305 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2305 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2306 = witTypes.Some[golem_core_types.NumericBound](variant2305) + default: + panic("unreachable") + } + var option2308 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2308 = witTypes.None[string]() + case 1: + value2307 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2308 = witTypes.Some[string](value2307) + default: + panic("unreachable") + } + + option2309 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2304, option2306, option2308}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU16Type(option2309) + + case 8: + var option2316 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2316 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2311 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2311 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2310 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2310 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2310 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2310 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2311 = witTypes.Some[golem_core_types.NumericBound](variant2310) + default: + panic("unreachable") + } + var option2313 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2313 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2312 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2312 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2312 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2312 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2313 = witTypes.Some[golem_core_types.NumericBound](variant2312) + default: + panic("unreachable") + } + var option2315 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2315 = witTypes.None[string]() + case 1: + value2314 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2315 = witTypes.Some[string](value2314) + default: + panic("unreachable") + } + + option2316 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2311, option2313, option2315}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU32Type(option2316) + + case 9: + var option2323 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2323 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2318 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2318 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2317 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2317 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2317 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2317 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2318 = witTypes.Some[golem_core_types.NumericBound](variant2317) + default: + panic("unreachable") + } + var option2320 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2320 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2319 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2319 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2319 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2319 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2320 = witTypes.Some[golem_core_types.NumericBound](variant2319) + default: + panic("unreachable") + } + var option2322 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2322 = witTypes.None[string]() + case 1: + value2321 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2322 = witTypes.Some[string](value2321) + default: + panic("unreachable") + } + + option2323 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2318, option2320, option2322}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU64Type(option2323) + + case 10: + var option2330 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2330 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2325 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2325 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2324 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2324 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2324 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2324 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2325 = witTypes.Some[golem_core_types.NumericBound](variant2324) + default: + panic("unreachable") + } + var option2327 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2327 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2326 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2326 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2326 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2326 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2327 = witTypes.Some[golem_core_types.NumericBound](variant2326) + default: + panic("unreachable") + } + var option2329 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2329 = witTypes.None[string]() + case 1: + value2328 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2329 = witTypes.Some[string](value2328) + default: + panic("unreachable") + } + + option2330 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2325, option2327, option2329}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyF32Type(option2330) + + case 11: + var option2337 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2337 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2332 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2332 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2331 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2331 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2331 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2331 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2332 = witTypes.Some[golem_core_types.NumericBound](variant2331) + default: + panic("unreachable") + } + var option2334 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2334 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2333 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2333 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2333 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2333 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2334 = witTypes.Some[golem_core_types.NumericBound](variant2333) + default: + panic("unreachable") + } + var option2336 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2336 = witTypes.None[string]() + case 1: + value2335 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2336 = witTypes.Some[string](value2335) + default: + panic("unreachable") + } + + option2337 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2332, option2334, option2336}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyF64Type(option2337) + + case 12: + + variant2431 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant2431 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result2350 := 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)) + value2338 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2340 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option2340 = witTypes.None[string]() + case 1: + value2339 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option2340 = witTypes.Some[string](value2339) + default: + panic("unreachable") + } + result2342 := 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)) + value2341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2342 = append(result2342, value2341) + } + + result2344 := 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)) + value2343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2344 = append(result2344, value2343) + } + + var option2346 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option2346 = witTypes.None[string]() + case 1: + value2345 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option2346 = witTypes.Some[string](value2345) + default: + panic("unreachable") + } + var option2349 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option2349 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2348 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant2348 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2348 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2348 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant2348 = golem_core_types.MakeRoleOther(value2347) + + default: + panic("unreachable") + } + + option2349 = witTypes.Some[golem_core_types.Role](variant2348) + default: + panic("unreachable") + } + + result2350 = append(result2350, golem_core_types.NamedFieldType{value2338, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2340, result2342, result2344, option2346, option2349}}) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyRecordType(result2350) + + case 15: + result2364 := 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)) + value2351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2352 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2352 = witTypes.None[int32]() + case 1: + + option2352 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option2354 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2354 = witTypes.None[string]() + case 1: + value2353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2354 = witTypes.Some[string](value2353) + default: + panic("unreachable") + } + result2356 := 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)) + value2355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2356 = append(result2356, value2355) + } + + result2358 := 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)) + value2357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2358 = append(result2358, value2357) + } + + var option2360 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option2360 = witTypes.None[string]() + case 1: + value2359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option2360 = witTypes.Some[string](value2359) + default: + panic("unreachable") + } + var option2363 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option2363 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2362 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant2362 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2362 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2362 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant2362 = golem_core_types.MakeRoleOther(value2361) + + default: + panic("unreachable") + } + + option2363 = witTypes.Some[golem_core_types.Role](variant2362) + default: + panic("unreachable") + } + + result2364 = append(result2364, golem_core_types.VariantCaseType{value2351, option2352, golem_core_types.MetadataEnvelope{option2354, result2356, result2358, option2360, option2363}}) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyVariantType(result2364) + + case 16: + result2366 := 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)) + value2365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2366 = append(result2366, value2365) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyEnumType(result2366) + + case 17: + result2368 := 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)) + value2367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2368 = append(result2368, value2367) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2368) + + case 18: + result2369 := 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) + + result2369 = append(result2369, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyTupleType(result2369) + + case 19: + + variant2431 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant2431 = 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: + + variant2431 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant2431 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option2370 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2370 = witTypes.None[int32]() + case 1: + + option2370 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option2371 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2371 = witTypes.None[int32]() + case 1: + + option2371 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2370, option2371}) + + case 24: + var option2374 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2374 = witTypes.None[[]string]() + case 1: + result2373 := 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)) + value2372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2373 = append(result2373, value2372) + } + + option2374 = witTypes.Some[[]string](result2373) + default: + panic("unreachable") + } + var option2375 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2375 = witTypes.None[uint32]() + case 1: + + option2375 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2376 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2376 = witTypes.None[uint32]() + case 1: + + option2376 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option2378 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option2378 = witTypes.None[string]() + case 1: + value2377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option2378 = witTypes.Some[string](value2377) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2374, option2375, option2376, option2378}) + + case 25: + var option2381 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2381 = witTypes.None[[]string]() + case 1: + result2380 := 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)) + value2379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2380 = append(result2380, value2379) + } + + option2381 = witTypes.Some[[]string](result2380) + default: + panic("unreachable") + } + var option2382 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2382 = witTypes.None[uint32]() + case 1: + + option2382 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2383 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2383 = witTypes.None[uint32]() + case 1: + + option2383 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2381, option2382, option2383}) + + case 26: + var option2386 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2386 = witTypes.None[[]string]() + case 1: + result2385 := 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)) + value2384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2385 = append(result2385, value2384) + } + + option2386 = witTypes.Some[[]string](result2385) + default: + panic("unreachable") + } + var option2389 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2389 = witTypes.None[[]string]() + case 1: + result2388 := 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)) + value2387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2388 = append(result2388, value2387) + } + + option2389 = witTypes.Some[[]string](result2388) + default: + panic("unreachable") + } + + variant2431 = 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)))), option2386, option2389}) + + case 27: + var option2392 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2392 = witTypes.None[[]string]() + case 1: + result2391 := 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)) + value2390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2391 = append(result2391, value2390) + } + + option2392 = witTypes.Some[[]string](result2391) + default: + panic("unreachable") + } + var option2395 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2395 = witTypes.None[[]string]() + case 1: + result2394 := 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)) + value2393 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2394 = append(result2394, value2393) + } + + option2395 = witTypes.Some[[]string](result2394) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2392, option2395}) + + case 28: + + variant2431 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant2431 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value2396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2398 := 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)) + value2397 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2398 = append(result2398, value2397) + } + + var option2400 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2400 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2399 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option2400 = 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))), value2399}) + default: + panic("unreachable") + } + var option2402 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option2402 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2401 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option2402 = 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))), value2401}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2396, result2398, option2400, option2402}) + + case 31: + result2424 := 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)) + value2403 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2412 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value2404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRulePrefix(value2404) + + case 1: + value2405 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleSuffix(value2405) + + case 2: + value2406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleContains(value2406) + + case 3: + value2407 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleRegex(value2407) + + case 4: + value2408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option2410 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option2410 = witTypes.None[string]() + case 1: + value2409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option2410 = witTypes.Some[string](value2409) + default: + panic("unreachable") + } + + variant2412 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2408, option2410}) + + case 5: + value2411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2411) + + default: + panic("unreachable") + } + var option2414 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option2414 = witTypes.None[string]() + case 1: + value2413 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option2414 = witTypes.Some[string](value2413) + default: + panic("unreachable") + } + result2416 := 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)) + value2415 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2416 = append(result2416, value2415) + } + + result2418 := 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)) + value2417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2418 = append(result2418, value2417) + } + + var option2420 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option2420 = witTypes.None[string]() + case 1: + value2419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option2420 = witTypes.Some[string](value2419) + default: + panic("unreachable") + } + var option2423 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option2423 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2422 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant2422 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2422 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2422 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant2422 = golem_core_types.MakeRoleOther(value2421) + + default: + panic("unreachable") + } + + option2423 = witTypes.Some[golem_core_types.Role](variant2422) + default: + panic("unreachable") + } + + result2424 = append(result2424, golem_core_types.UnionBranch{value2403, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2412, golem_core_types.MetadataEnvelope{option2414, result2416, result2418, option2420, option2423}}) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2424}) + + case 32: + var option2426 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2426 = witTypes.None[string]() + case 1: + value2425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option2426 = witTypes.Some[string](value2425) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2426}) + + case 33: + var option2428 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2428 = witTypes.None[string]() + case 1: + value2427 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option2428 = witTypes.Some[string](value2427) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2428}) + + case 34: + + variant2431 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyFutureType(option2429) + + case 36: + var option2430 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2430 = witTypes.None[int32]() + case 1: + + option2430 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyStreamType(option2430) + + default: + panic("unreachable") + } + var option2433 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option2433 = witTypes.None[string]() + case 1: + value2432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option2433 = witTypes.Some[string](value2432) + default: + panic("unreachable") + } + result2435 := 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)) + value2434 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2435 = append(result2435, value2434) + } + + result2437 := 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)) + value2436 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2437 = append(result2437, value2436) + } + + var option2439 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option2439 = witTypes.None[string]() + case 1: + value2438 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option2439 = witTypes.Some[string](value2438) + default: + panic("unreachable") + } + var option2442 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option2442 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2441 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant2441 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2441 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2441 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2440 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant2441 = golem_core_types.MakeRoleOther(value2440) + + default: + panic("unreachable") + } + + option2442 = witTypes.Some[golem_core_types.Role](variant2441) + default: + panic("unreachable") + } + + result2443 = append(result2443, golem_core_types.SchemaTypeNode{variant2431, golem_core_types.MetadataEnvelope{option2433, result2435, result2437, option2439, option2442}}) + } + + result2447 := 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)) + value2444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2446 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2446 = witTypes.None[string]() + case 1: + value2445 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option2446 = witTypes.Some[string](value2445) + default: + panic("unreachable") + } + + result2447 = append(result2447, golem_core_types.SchemaTypeDef{value2444, option2446, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result2471 := 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 variant2470 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2470 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant2470 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant2470 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant2470 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant2470 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant2470 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant2470 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant2470 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant2470 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant2470 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant2470 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant2470 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value2448 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeStringValue(value2448) + + case 13: + result2449 := 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) + + result2449 = append(result2449, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeRecordValue(result2449) + + case 14: + var option2450 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2450 = witTypes.None[int32]() + case 1: + + option2450 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2450}) + + case 15: + + variant2470 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result2451 := 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) + + result2451 = append(result2451, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2451) + + case 17: + 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))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeTupleValue(result2452) + + case 18: + 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))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeListValue(result2453) + + case 19: + result2454 := 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) + + result2454 = append(result2454, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2454) + + case 20: + result2455 := 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) + + result2455 = append(result2455, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeMapValue(result2455) + + case 21: + var option2456 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2456 = witTypes.None[int32]() + case 1: + + option2456 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeOptionValue(option2456) + + case 22: + var variant2459 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant2459 = golem_core_types.MakeResultValuePayloadOkValue(option2457) + + case 1: + var option2458 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2458 = witTypes.None[int32]() + case 1: + + option2458 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2459 = golem_core_types.MakeResultValuePayloadErrValue(option2458) + + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeResultValue(variant2459) + + case 23: + value2460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2462 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2462 = witTypes.None[string]() + case 1: + value2461 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2462 = witTypes.Some[string](value2461) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2460, option2462}) + + case 24: + value2463 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2465 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2465 = witTypes.None[string]() + case 1: + value2464 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2465 = witTypes.Some[string](value2464) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2463, option2465}) + + case 25: + value2466 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodePathValue(value2466) + + case 26: + value2467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeUrlValue(value2467) + + case 27: + + variant2470 = 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: + + variant2470 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value2468 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2468}) + + case 30: + value2469 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2469, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant2470 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant2470 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant2470 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result2471 = append(result2471, variant2470) + } + + variant2472 = 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{result2443, result2447, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result2471, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}}) + + case 46: + + variant2472 = 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)))}) + + case 47: + + variant2472 = MakePublicOplogEntryCompletionDelivered(CompletionDeliveredParameters{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") + } + + result2473 = append(result2473, variant2472) + } + + option2474 = witTypes.Some[[]PublicOplogEntry](result2473) + default: + panic("unreachable") + } + + result2477 = witTypes.Ok[witTypes.Option[[]PublicOplogEntry], OplogReadError](option2474) + case 1: + var variant2476 OplogReadError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant2476 = MakeOplogReadErrorPermissionDenied() + + case 1: + value2475 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant2476 = MakeOplogReadErrorInternalError(value2475) + + default: + panic("unreachable") + } + + result2477 = witTypes.Err[witTypes.Option[[]PublicOplogEntry], OplogReadError](variant2476) + default: + panic("unreachable") + } + result2478 := result2477 + return result2478 + +} + +//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.Result[witTypes.Option[[]witTypes.Tuple2[uint64, PublicOplogEntry]], OplogReadError] { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4)) + wasm_import_method_search_oplog_get_next((self).Handle(), returnArea) + var result2477 witTypes.Result[witTypes.Option[[]witTypes.Tuple2[uint64, PublicOplogEntry]], OplogReadError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + var option2474 witTypes.Option[[]witTypes.Tuple2[uint64, PublicOplogEntry]] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + option2474 = witTypes.None[[]witTypes.Tuple2[uint64, PublicOplogEntry]]() + case 1: + result2473 := make([]witTypes.Tuple2[uint64, PublicOplogEntry], 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*(176+10*4)) + var variant2472 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: + + variant173 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + 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 36: + 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)))))) + + case 33: + + variant212 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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") + } + + variant2472 = 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 option218 witTypes.Option[golem_core_types.Uuid] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))) { + case 0: + + option218 = witTypes.None[golem_core_types.Uuid]() + case 1: + + option218 = witTypes.Some[golem_core_types.Uuid](golem_core_types.Uuid{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (56 + 2*4)))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4))))}) + default: + panic("unreachable") + } + var option219 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 2*4)))) { + case 0: + + option219 = witTypes.None[uint64]() + case 1: + + option219 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (80 + 2*4))))) + default: + panic("unreachable") + } + var option424 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 2*4)))) { + case 0: + + option424 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result395 := make([]golem_core_types.SchemaTypeNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 4*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 3*4))))), index*(56+22*4)) + var variant383 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant383 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant383 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS8Type(option226) + + case 3: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS16Type(option233) + + case 4: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS32Type(option240) + + case 5: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyS64Type(option247) + + case 6: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU8Type(option254) + + case 7: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU16Type(option261) + + case 8: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU32Type(option268) + + case 9: + 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") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyU64Type(option275) + + case 10: + var option282 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option282 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option277 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant276 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant276 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant276 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option277 = witTypes.Some[golem_core_types.NumericBound](variant276) + default: + panic("unreachable") + } + var option279 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option279 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant278 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant278 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant278 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant278 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option279 = witTypes.Some[golem_core_types.NumericBound](variant278) + default: + panic("unreachable") + } + var option281 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option281 = witTypes.None[string]() + case 1: + value280 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option281 = witTypes.Some[string](value280) + default: + panic("unreachable") + } + + option282 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option277, option279, option281}) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyF32Type(option282) + + case 11: + var option289 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option289 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option284 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option284 = witTypes.Some[golem_core_types.NumericBound](variant283) + default: + panic("unreachable") + } + var option286 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option286 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant285 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant285 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant285 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant285 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option286 = witTypes.Some[golem_core_types.NumericBound](variant285) + default: + panic("unreachable") + } + var option288 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option288 = witTypes.None[string]() + case 1: + value287 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option288 = witTypes.Some[string](value287) + default: + panic("unreachable") + } + + option289 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option284, option286, option288}) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyF64Type(option289) + + case 12: + + variant383 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant383 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result302 := 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)) + value290 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option292 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option292 = witTypes.None[string]() + case 1: + value291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option292 = witTypes.Some[string](value291) + default: + panic("unreachable") + } + result294 := 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)) + 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), (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)) + 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), (10 * 4)))) { + case 0: + + option298 = witTypes.None[string]() + case 1: + value297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 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), (13 * 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), (14 * 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), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 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.NamedFieldType{value290, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option292, result294, result296, option298, option301}}) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyRecordType(result302) + + case 15: + result316 := 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)) + value303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option304 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option304 = witTypes.None[int32]() + case 1: + + option304 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option306 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option306 = witTypes.None[string]() + case 1: + value305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option306 = witTypes.Some[string](value305) + default: + panic("unreachable") + } + result308 := 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)) + 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) + } + + result310 := 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)) + value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result310 = append(result310, value309) + } + + var option312 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option312 = witTypes.None[string]() + case 1: + value311 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option312 = witTypes.Some[string](value311) + default: + panic("unreachable") + } + var option315 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option315 = witTypes.None[golem_core_types.Role]() + case 1: + var variant314 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant314 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant314 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant314 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant314 = golem_core_types.MakeRoleOther(value313) + + default: + panic("unreachable") + } + + option315 = witTypes.Some[golem_core_types.Role](variant314) + default: + panic("unreachable") + } + + result316 = append(result316, golem_core_types.VariantCaseType{value303, option304, golem_core_types.MetadataEnvelope{option306, result308, result310, option312, option315}}) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyVariantType(result316) + + case 16: + 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) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyEnumType(result318) + + case 17: + result320 := 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)) + 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) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyFlagsType(result320) + + case 18: + result321 := 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) + + result321 = append(result321, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyTupleType(result321) + + case 19: + + variant383 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant383 = 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: + + variant383 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant383 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option322 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option322 = witTypes.None[int32]() + case 1: + + option322 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option323 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option323 = witTypes.None[int32]() + case 1: + + option323 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option322, option323}) + + case 24: + var option326 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option326 = witTypes.None[[]string]() + case 1: + result325 := 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)) + value324 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result325 = append(result325, value324) + } + + option326 = witTypes.Some[[]string](result325) + default: + panic("unreachable") + } + var option327 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option327 = witTypes.None[uint32]() + case 1: + + option327 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option328 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option328 = witTypes.None[uint32]() + case 1: + + option328 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option330 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option330 = witTypes.None[string]() + case 1: + value329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option330 = witTypes.Some[string](value329) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option326, option327, option328, option330}) + + case 25: + var option333 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option333 = witTypes.None[[]string]() + case 1: + result332 := 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)) + 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") + } + var option334 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option334 = witTypes.None[uint32]() + case 1: + + option334 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option335 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option335 = witTypes.None[uint32]() + case 1: + + option335 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option333, option334, option335}) + + case 26: + var option338 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option338 = witTypes.None[[]string]() + case 1: + result337 := 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)) + 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 option341 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option341 = witTypes.None[[]string]() + case 1: + result340 := 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)) + 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) + } + + option341 = witTypes.Some[[]string](result340) + default: + panic("unreachable") + } + + variant383 = 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)))), option338, option341}) + + case 27: + var option344 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option344 = witTypes.None[[]string]() + case 1: + result343 := 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)) + value342 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result343 = append(result343, value342) + } + + option344 = witTypes.Some[[]string](result343) + default: + panic("unreachable") + } + var option347 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option347 = witTypes.None[[]string]() + case 1: + result346 := 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)) + value345 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result346 = append(result346, value345) + } + + option347 = witTypes.Some[[]string](result346) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option344, option347}) + + case 28: + + variant383 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant383 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value348 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result350 := 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)) + value349 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result350 = append(result350, value349) + } + + var option352 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option352 = 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))), value351}) + default: + panic("unreachable") + } + var option354 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option354 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option354 = 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))), value353}) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value348, result350, option352, option354}) + + case 31: + result376 := 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)) + value355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant364 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRulePrefix(value356) + + case 1: + value357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleSuffix(value357) + + case 2: + value358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleContains(value358) + + case 3: + value359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleRegex(value359) + + case 4: + value360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option362 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option362 = witTypes.None[string]() + case 1: + value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option362 = witTypes.Some[string](value361) + default: + panic("unreachable") + } + + variant364 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value360, option362}) + + case 5: + value363 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant364 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value363) + + default: + panic("unreachable") + } + var option366 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option366 = witTypes.None[string]() + case 1: + value365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option366 = witTypes.Some[string](value365) + default: + panic("unreachable") + } + result368 := 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)) + 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) + } + + result370 := 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)) + value369 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result370 = append(result370, value369) + } + + var option372 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option372 = witTypes.None[string]() + case 1: + value371 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option372 = witTypes.Some[string](value371) + default: + panic("unreachable") + } + var option375 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option375 = witTypes.None[golem_core_types.Role]() + case 1: + var variant374 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant374 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant374 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant374 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value373 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant374 = golem_core_types.MakeRoleOther(value373) + + default: + panic("unreachable") + } + + option375 = witTypes.Some[golem_core_types.Role](variant374) + default: + panic("unreachable") + } + + result376 = append(result376, golem_core_types.UnionBranch{value355, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant364, golem_core_types.MetadataEnvelope{option366, result368, result370, option372, option375}}) + } + + variant383 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result376}) + + case 32: + var option378 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option378 = witTypes.None[string]() + case 1: + value377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option378 = witTypes.Some[string](value377) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option378}) + + case 33: + var option380 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option380 = witTypes.None[string]() + case 1: + value379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option380 = witTypes.Some[string](value379) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option380}) + + case 34: + + variant383 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option381 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option381 = witTypes.None[int32]() + case 1: + + option381 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyFutureType(option381) + + case 36: + var option382 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option382 = witTypes.None[int32]() + case 1: + + option382 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant383 = golem_core_types.MakeSchemaTypeBodyStreamType(option382) + + default: + panic("unreachable") + } + var option385 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option385 = witTypes.None[string]() + case 1: + value384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option385 = witTypes.Some[string](value384) + default: + panic("unreachable") + } + result387 := 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)) + 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) + } + + result389 := 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)) + value388 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result389 = append(result389, value388) + } + + var option391 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option391 = witTypes.None[string]() + case 1: + value390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option391 = witTypes.Some[string](value390) + default: + panic("unreachable") + } + var option394 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option394 = witTypes.None[golem_core_types.Role]() + case 1: + var variant393 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant393 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant393 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant393 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant393 = golem_core_types.MakeRoleOther(value392) + + default: + panic("unreachable") + } + + option394 = witTypes.Some[golem_core_types.Role](variant393) + default: + panic("unreachable") + } + + result395 = append(result395, golem_core_types.SchemaTypeNode{variant383, golem_core_types.MetadataEnvelope{option385, result387, result389, option391, option394}}) + } + + result399 := make([]golem_core_types.SchemaTypeDef, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 6*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 6*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 5*4))))), index*(6*4)) + value396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option398 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option398 = witTypes.None[string]() + case 1: + value397 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option398 = witTypes.Some[string](value397) + default: + panic("unreachable") + } + + result399 = append(result399, golem_core_types.SchemaTypeDef{value396, option398, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result423 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 9*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 9*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (88 + 8*4))))), index*(16+4*4)) + var variant422 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant422 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant422 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant422 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant422 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant422 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant422 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant422 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant422 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant422 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant422 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant422 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant422 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value400 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeStringValue(value400) + + case 13: + result401 := 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) + + result401 = append(result401, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeRecordValue(result401) + + case 14: + var option402 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option402 = witTypes.None[int32]() + case 1: + + option402 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option402}) + + case 15: + + variant422 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result403 := 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) + + result403 = append(result403, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant422 = golem_core_types.MakeSchemaValueNodeFlagsValue(result403) + + case 17: + 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))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeTupleValue(result404) + + case 18: + result405 := 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) + + result405 = append(result405, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeListValue(result405) + + case 19: + result406 := 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) + + result406 = append(result406, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant422 = golem_core_types.MakeSchemaValueNodeFixedListValue(result406) + + case 20: + result407 := 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) + + result407 = append(result407, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant422 = golem_core_types.MakeSchemaValueNodeMapValue(result407) + + case 21: + var option408 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option408 = witTypes.None[int32]() + case 1: + + option408 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeOptionValue(option408) + + case 22: + var variant411 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option409 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option409 = witTypes.None[int32]() + case 1: + + option409 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant411 = golem_core_types.MakeResultValuePayloadOkValue(option409) + + case 1: + var option410 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option410 = witTypes.None[int32]() + case 1: + + option410 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant411 = golem_core_types.MakeResultValuePayloadErrValue(option410) + + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeResultValue(variant411) + + case 23: + value412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option414 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option414 = witTypes.None[string]() + case 1: + value413 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option414 = witTypes.Some[string](value413) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value412, option414}) + + case 24: + value415 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option417 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option417 = witTypes.None[string]() + case 1: + value416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option417 = witTypes.Some[string](value416) + default: + panic("unreachable") + } + + variant422 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value415, option417}) + + case 25: + value418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodePathValue(value418) + + case 26: + value419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeUrlValue(value419) + + case 27: + + variant422 = 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: + + variant422 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value420}) + + case 30: + value421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant422 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value421, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant422 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant422 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant422 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result423 = append(result423, variant422) + } + + option424 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result395, result399, *(*int32)(unsafe.Add(unsafe.Pointer(base), (88 + 7*4)))}, golem_core_types.SchemaValueTree{result423, *(*int32)(unsafe.Add(unsafe.Pointer(base), (88 + 10*4)))}}) + default: + panic("unreachable") + } + var variant427 WrappedFunctionType + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (96 + 10*4)))) { + case 0: + + variant427 = MakeWrappedFunctionTypeReadLocal() + + case 1: + + variant427 = MakeWrappedFunctionTypeWriteLocal() + + case 2: + + variant427 = MakeWrappedFunctionTypeReadRemote() + + case 3: + + variant427 = MakeWrappedFunctionTypeWriteRemote() + + case 4: + var option425 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (104 + 10*4)))) { + case 0: + + option425 = witTypes.None[uint64]() + case 1: + + option425 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (112 + 10*4))))) + default: + panic("unreachable") + } + + variant427 = MakeWrappedFunctionTypeWriteRemoteBatched(option425) + + case 5: + var option426 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (104 + 10*4)))) { + case 0: + + option426 = witTypes.None[uint64]() + case 1: + + option426 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (112 + 10*4))))) + default: + panic("unreachable") + } + + variant427 = MakeWrappedFunctionTypeWriteRemoteTransaction(option426) + + default: + panic("unreachable") + } + + variant2472 = 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, option218, option219, option424, variant427}) + + case 2: + var option632 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option632 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result603 := 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 variant591 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant591 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant591 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option434 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option434 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option429 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant428 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant428 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant428 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option429 = witTypes.Some[golem_core_types.NumericBound](variant428) + default: + panic("unreachable") + } + var option431 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option431 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant430 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant430 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant430 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant430 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option431 = witTypes.Some[golem_core_types.NumericBound](variant430) + default: + panic("unreachable") + } + var option433 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option433 = witTypes.None[string]() + case 1: + value432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option433 = witTypes.Some[string](value432) + default: + panic("unreachable") + } + + option434 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option429, option431, option433}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS8Type(option434) + + case 3: + var option441 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option441 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option436 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant435 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant435 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant435 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option436 = witTypes.Some[golem_core_types.NumericBound](variant435) + default: + panic("unreachable") + } + var option438 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option438 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant437 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant437 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant437 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant437 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option438 = witTypes.Some[golem_core_types.NumericBound](variant437) + default: + panic("unreachable") + } + var option440 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option440 = witTypes.None[string]() + case 1: + value439 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option440 = witTypes.Some[string](value439) + default: + panic("unreachable") + } + + option441 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option436, option438, option440}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS16Type(option441) + + case 4: + var option448 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option448 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option443 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant442 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant442 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant442 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option443 = witTypes.Some[golem_core_types.NumericBound](variant442) + default: + panic("unreachable") + } + var option445 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option445 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant444 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant444 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant444 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant444 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option445 = witTypes.Some[golem_core_types.NumericBound](variant444) + default: + panic("unreachable") + } + var option447 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option447 = witTypes.None[string]() + case 1: + value446 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option447 = witTypes.Some[string](value446) + default: + panic("unreachable") + } + + option448 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option443, option445, option447}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS32Type(option448) + + case 5: + var option455 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option455 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option450 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant449 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant449 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant449 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option450 = witTypes.Some[golem_core_types.NumericBound](variant449) + default: + panic("unreachable") + } + var option452 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option452 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant451 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant451 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant451 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant451 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option452 = witTypes.Some[golem_core_types.NumericBound](variant451) + default: + panic("unreachable") + } + var option454 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option454 = witTypes.None[string]() + case 1: + value453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option454 = witTypes.Some[string](value453) + default: + panic("unreachable") + } + + option455 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option450, option452, option454}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyS64Type(option455) + + case 6: + var option462 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option462 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option457 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant456 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant456 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant456 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option457 = witTypes.Some[golem_core_types.NumericBound](variant456) + default: + panic("unreachable") + } + var option459 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option459 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant458 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant458 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant458 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant458 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option459 = witTypes.Some[golem_core_types.NumericBound](variant458) + default: + panic("unreachable") + } + var option461 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option461 = witTypes.None[string]() + case 1: + value460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option461 = witTypes.Some[string](value460) + default: + panic("unreachable") + } + + option462 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option457, option459, option461}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU8Type(option462) + + case 7: + var option469 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option469 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option464 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant463 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant463 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant463 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option464 = witTypes.Some[golem_core_types.NumericBound](variant463) + default: + panic("unreachable") + } + var option466 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option466 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant465 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant465 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant465 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant465 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option466 = witTypes.Some[golem_core_types.NumericBound](variant465) + default: + panic("unreachable") + } + var option468 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option468 = witTypes.None[string]() + case 1: + value467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option468 = witTypes.Some[string](value467) + default: + panic("unreachable") + } + + option469 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option464, option466, option468}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU16Type(option469) + + case 8: + var option476 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option476 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option471 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant470 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant470 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant470 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option471 = witTypes.Some[golem_core_types.NumericBound](variant470) + default: + panic("unreachable") + } + var option473 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option473 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant472 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant472 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant472 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant472 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option473 = witTypes.Some[golem_core_types.NumericBound](variant472) + default: + panic("unreachable") + } + var option475 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option475 = witTypes.None[string]() + case 1: + value474 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option475 = witTypes.Some[string](value474) + default: + panic("unreachable") + } + + option476 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option471, option473, option475}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU32Type(option476) + + case 9: + var option483 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option483 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option478 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant477 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant477 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant477 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option478 = witTypes.Some[golem_core_types.NumericBound](variant477) + default: + panic("unreachable") + } + var option480 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option480 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant479 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant479 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant479 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant479 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option480 = witTypes.Some[golem_core_types.NumericBound](variant479) + default: + panic("unreachable") + } + var option482 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option482 = witTypes.None[string]() + case 1: + value481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option482 = witTypes.Some[string](value481) + default: + panic("unreachable") + } + + option483 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option478, option480, option482}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyU64Type(option483) + + case 10: + var option490 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option490 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option485 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant484 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant484 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant484 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option485 = witTypes.Some[golem_core_types.NumericBound](variant484) + default: + panic("unreachable") + } + var option487 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option487 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant486 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant486 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant486 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant486 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option487 = witTypes.Some[golem_core_types.NumericBound](variant486) + default: + panic("unreachable") + } + var option489 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option489 = witTypes.None[string]() + case 1: + value488 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option489 = witTypes.Some[string](value488) + default: + panic("unreachable") + } + + option490 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option485, option487, option489}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyF32Type(option490) + + case 11: + var option497 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option497 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option492 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant491 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant491 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant491 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option492 = witTypes.Some[golem_core_types.NumericBound](variant491) + default: + panic("unreachable") + } + var option494 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option494 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant493 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant493 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant493 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant493 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option494 = witTypes.Some[golem_core_types.NumericBound](variant493) + default: + panic("unreachable") + } + var option496 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option496 = witTypes.None[string]() + case 1: + value495 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option496 = witTypes.Some[string](value495) + default: + panic("unreachable") + } + + option497 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option492, option494, option496}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyF64Type(option497) + + case 12: + + variant591 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant591 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result510 := 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)) + value498 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option500 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option500 = witTypes.None[string]() + case 1: + value499 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option500 = witTypes.Some[string](value499) + default: + panic("unreachable") + } + result502 := 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)) + 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) + } + + result504 := 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)) + value503 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result504 = append(result504, value503) + } + + var option506 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option506 = witTypes.None[string]() + case 1: + value505 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option506 = witTypes.Some[string](value505) + default: + panic("unreachable") + } + var option509 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option509 = witTypes.None[golem_core_types.Role]() + case 1: + var variant508 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant508 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant508 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant508 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value507 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant508 = golem_core_types.MakeRoleOther(value507) + + default: + panic("unreachable") + } + + option509 = witTypes.Some[golem_core_types.Role](variant508) + default: + panic("unreachable") + } + + result510 = append(result510, golem_core_types.NamedFieldType{value498, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option500, result502, result504, option506, option509}}) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyRecordType(result510) + + case 15: + result524 := 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)) + value511 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option512 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option512 = witTypes.None[int32]() + case 1: + + option512 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option514 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option514 = witTypes.None[string]() + case 1: + value513 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option514 = witTypes.Some[string](value513) + default: + panic("unreachable") + } + result516 := 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)) + 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) + } + + result518 := 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)) + value517 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result518 = append(result518, value517) + } + + var option520 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option520 = witTypes.None[string]() + case 1: + value519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option520 = witTypes.Some[string](value519) + default: + panic("unreachable") + } + var option523 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option523 = witTypes.None[golem_core_types.Role]() + case 1: + var variant522 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant522 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant522 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant522 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value521 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant522 = golem_core_types.MakeRoleOther(value521) + + default: + panic("unreachable") + } + + option523 = witTypes.Some[golem_core_types.Role](variant522) + default: + panic("unreachable") + } + + result524 = append(result524, golem_core_types.VariantCaseType{value511, option512, golem_core_types.MetadataEnvelope{option514, result516, result518, option520, option523}}) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyVariantType(result524) + + case 16: + 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) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyEnumType(result526) + + case 17: + result528 := 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)) + 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) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyFlagsType(result528) + + case 18: + result529 := 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) + + result529 = append(result529, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyTupleType(result529) + + case 19: + + variant591 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant591 = 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: + + variant591 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant591 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option530 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option530 = witTypes.None[int32]() + case 1: + + option530 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option531 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option531 = witTypes.None[int32]() + case 1: + + option531 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option530, option531}) + + case 24: + var option534 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option534 = witTypes.None[[]string]() + case 1: + result533 := 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)) + value532 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result533 = append(result533, value532) + } + + option534 = witTypes.Some[[]string](result533) + default: + panic("unreachable") + } + var option535 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option535 = witTypes.None[uint32]() + case 1: + + option535 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option536 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option536 = witTypes.None[uint32]() + case 1: + + option536 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option538 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option538 = witTypes.None[string]() + case 1: + value537 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option538 = witTypes.Some[string](value537) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option534, option535, option536, option538}) + + case 25: + var option541 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option541 = witTypes.None[[]string]() + case 1: + result540 := 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)) + 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) + } + + option541 = witTypes.Some[[]string](result540) + default: + panic("unreachable") + } + var option542 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option542 = witTypes.None[uint32]() + case 1: + + option542 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option543 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option543 = witTypes.None[uint32]() + case 1: + + option543 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option541, option542, option543}) + + case 26: + var option546 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option546 = witTypes.None[[]string]() + case 1: + result545 := 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)) + 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 option549 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option549 = witTypes.None[[]string]() + case 1: + result548 := 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)) + value547 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result548 = append(result548, value547) + } + + option549 = witTypes.Some[[]string](result548) + default: + panic("unreachable") + } + + variant591 = 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)))), option546, option549}) + + case 27: + var option552 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option552 = witTypes.None[[]string]() + case 1: + result551 := 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)) + value550 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result551 = append(result551, value550) + } + + option552 = witTypes.Some[[]string](result551) + default: + panic("unreachable") + } + var option555 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option555 = witTypes.None[[]string]() + case 1: + result554 := 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)) + value553 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result554 = append(result554, value553) + } + + option555 = witTypes.Some[[]string](result554) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option552, option555}) + + case 28: + + variant591 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant591 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value556 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result558 := 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)) + value557 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result558 = append(result558, value557) + } + + var option560 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option560 = 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))), value559}) + default: + panic("unreachable") + } + var option562 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option562 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value561 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option562 = 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))), value561}) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value556, result558, option560, option562}) + + case 31: + result584 := 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)) + value563 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant572 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRulePrefix(value564) + + case 1: + value565 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleSuffix(value565) + + case 2: + value566 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleContains(value566) + + case 3: + value567 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleRegex(value567) + + case 4: + value568 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option570 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option570 = witTypes.None[string]() + case 1: + value569 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option570 = witTypes.Some[string](value569) + default: + panic("unreachable") + } + + variant572 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value568, option570}) + + case 5: + value571 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant572 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value571) + + default: + panic("unreachable") + } + var option574 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option574 = witTypes.None[string]() + case 1: + value573 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option574 = witTypes.Some[string](value573) + default: + panic("unreachable") + } + result576 := 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)) + 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) + } + + result578 := 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)) + value577 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result578 = append(result578, value577) + } + + var option580 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option580 = witTypes.None[string]() + case 1: + value579 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option580 = witTypes.Some[string](value579) + default: + panic("unreachable") + } + var option583 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option583 = witTypes.None[golem_core_types.Role]() + case 1: + var variant582 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant582 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant582 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant582 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value581 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant582 = golem_core_types.MakeRoleOther(value581) + + default: + panic("unreachable") + } + + option583 = witTypes.Some[golem_core_types.Role](variant582) + default: + panic("unreachable") + } + + result584 = append(result584, golem_core_types.UnionBranch{value563, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant572, golem_core_types.MetadataEnvelope{option574, result576, result578, option580, option583}}) + } + + variant591 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result584}) + + case 32: + var option586 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option586 = witTypes.None[string]() + case 1: + value585 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option586 = witTypes.Some[string](value585) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option586}) + + case 33: + var option588 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option588 = witTypes.None[string]() + case 1: + value587 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option588 = witTypes.Some[string](value587) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option588}) + + case 34: + + variant591 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option589 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option589 = witTypes.None[int32]() + case 1: + + option589 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyFutureType(option589) + + case 36: + var option590 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option590 = witTypes.None[int32]() + case 1: + + option590 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant591 = golem_core_types.MakeSchemaTypeBodyStreamType(option590) + + default: + panic("unreachable") + } + var option593 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option593 = witTypes.None[string]() + case 1: + value592 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option593 = witTypes.Some[string](value592) + default: + panic("unreachable") + } + result595 := 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)) + 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) + } + + result597 := 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)) + value596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result597 = append(result597, value596) + } + + var option599 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option599 = witTypes.None[string]() + case 1: + value598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option599 = witTypes.Some[string](value598) + default: + panic("unreachable") + } + var option602 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option602 = witTypes.None[golem_core_types.Role]() + case 1: + var variant601 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant601 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant601 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant601 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value600 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant601 = golem_core_types.MakeRoleOther(value600) + + default: + panic("unreachable") + } + + option602 = witTypes.Some[golem_core_types.Role](variant601) + default: + panic("unreachable") + } + + result603 = append(result603, golem_core_types.SchemaTypeNode{variant591, golem_core_types.MetadataEnvelope{option593, result595, result597, option599, option602}}) + } + + result607 := 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)) + value604 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option606 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option606 = witTypes.None[string]() + case 1: + value605 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option606 = witTypes.Some[string](value605) + default: + panic("unreachable") + } + + result607 = append(result607, golem_core_types.SchemaTypeDef{value604, option606, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result631 := 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 variant630 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant630 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant630 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant630 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant630 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant630 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant630 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant630 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant630 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant630 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant630 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant630 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant630 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value608 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeStringValue(value608) + + case 13: + result609 := 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) + + result609 = append(result609, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeRecordValue(result609) + + case 14: + var option610 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option610 = witTypes.None[int32]() + case 1: + + option610 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option610}) + + case 15: + + variant630 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result611 := 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) + + result611 = append(result611, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant630 = golem_core_types.MakeSchemaValueNodeFlagsValue(result611) + + case 17: + 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))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeTupleValue(result612) + + case 18: + result613 := 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) + + result613 = append(result613, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeListValue(result613) + + case 19: + result614 := 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) + + result614 = append(result614, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant630 = golem_core_types.MakeSchemaValueNodeFixedListValue(result614) + + case 20: + result615 := 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) + + result615 = append(result615, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant630 = golem_core_types.MakeSchemaValueNodeMapValue(result615) + + case 21: + var option616 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option616 = witTypes.None[int32]() + case 1: + + option616 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeOptionValue(option616) + + case 22: + var variant619 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option617 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option617 = witTypes.None[int32]() + case 1: + + option617 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant619 = golem_core_types.MakeResultValuePayloadOkValue(option617) + + case 1: + var option618 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option618 = witTypes.None[int32]() + case 1: + + option618 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant619 = golem_core_types.MakeResultValuePayloadErrValue(option618) + + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeResultValue(variant619) + + case 23: + value620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option622 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option622 = witTypes.None[string]() + case 1: + value621 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option622 = witTypes.Some[string](value621) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value620, option622}) + + case 24: + value623 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option625 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option625 = witTypes.None[string]() + case 1: + value624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option625 = witTypes.Some[string](value624) + default: + panic("unreachable") + } + + variant630 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value623, option625}) + + case 25: + value626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodePathValue(value626) + + case 26: + value627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeUrlValue(value627) + + case 27: + + variant630 = 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: + + variant630 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value628}) + + case 30: + value629 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant630 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value629, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant630 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant630 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant630 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result631 = append(result631, variant630) + } + + option632 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result603, result607, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))}, golem_core_types.SchemaValueTree{result631, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}}) + default: + panic("unreachable") + } + + variant2472 = 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))), option632, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))) != 0)}) + + case 3: + var option837 witTypes.Option[golem_core_types.TypedSchemaValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option837 = witTypes.None[golem_core_types.TypedSchemaValue]() + case 1: + result808 := 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 variant796 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant796 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant796 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option639 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option639 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option634 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant633 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant633 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant633 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option634 = witTypes.Some[golem_core_types.NumericBound](variant633) + default: + panic("unreachable") + } + var option636 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option636 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant635 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant635 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant635 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant635 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option636 = witTypes.Some[golem_core_types.NumericBound](variant635) + default: + panic("unreachable") + } + var option638 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option638 = witTypes.None[string]() + case 1: + value637 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option638 = witTypes.Some[string](value637) + default: + panic("unreachable") + } + + option639 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option634, option636, option638}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS8Type(option639) + + case 3: + var option646 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option646 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option641 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant640 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant640 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant640 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option641 = witTypes.Some[golem_core_types.NumericBound](variant640) + default: + panic("unreachable") + } + var option643 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option643 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant642 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant642 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant642 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant642 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option643 = witTypes.Some[golem_core_types.NumericBound](variant642) + default: + panic("unreachable") + } + var option645 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option645 = witTypes.None[string]() + case 1: + value644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option645 = witTypes.Some[string](value644) + default: + panic("unreachable") + } + + option646 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option641, option643, option645}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS16Type(option646) + + case 4: + var option653 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option653 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option648 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant647 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant647 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant647 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option648 = witTypes.Some[golem_core_types.NumericBound](variant647) + default: + panic("unreachable") + } + var option650 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option650 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant649 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant649 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant649 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant649 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option650 = witTypes.Some[golem_core_types.NumericBound](variant649) + default: + panic("unreachable") + } + var option652 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option652 = witTypes.None[string]() + case 1: + value651 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option652 = witTypes.Some[string](value651) + default: + panic("unreachable") + } + + option653 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option648, option650, option652}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS32Type(option653) + + case 5: + var option660 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option660 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option655 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant654 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant654 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant654 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option655 = witTypes.Some[golem_core_types.NumericBound](variant654) + default: + panic("unreachable") + } + var option657 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option657 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant656 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant656 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant656 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant656 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option657 = witTypes.Some[golem_core_types.NumericBound](variant656) + default: + panic("unreachable") + } + var option659 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option659 = witTypes.None[string]() + case 1: + value658 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option659 = witTypes.Some[string](value658) + default: + panic("unreachable") + } + + option660 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option655, option657, option659}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyS64Type(option660) + + case 6: + var option667 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option667 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option662 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant661 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant661 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant661 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option662 = witTypes.Some[golem_core_types.NumericBound](variant661) + default: + panic("unreachable") + } + var option664 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option664 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant663 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant663 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant663 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant663 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option664 = witTypes.Some[golem_core_types.NumericBound](variant663) + default: + panic("unreachable") + } + var option666 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option666 = witTypes.None[string]() + case 1: + value665 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option666 = witTypes.Some[string](value665) + default: + panic("unreachable") + } + + option667 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option662, option664, option666}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU8Type(option667) + + case 7: + var option674 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option674 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option669 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant668 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant668 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant668 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option669 = witTypes.Some[golem_core_types.NumericBound](variant668) + default: + panic("unreachable") + } + var option671 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option671 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant670 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant670 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant670 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant670 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option671 = witTypes.Some[golem_core_types.NumericBound](variant670) + default: + panic("unreachable") + } + var option673 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option673 = witTypes.None[string]() + case 1: + value672 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option673 = witTypes.Some[string](value672) + default: + panic("unreachable") + } + + option674 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option669, option671, option673}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU16Type(option674) + + case 8: + var option681 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option681 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option676 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant675 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant675 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant675 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option676 = witTypes.Some[golem_core_types.NumericBound](variant675) + default: + panic("unreachable") + } + var option678 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option678 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant677 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant677 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant677 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant677 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option678 = witTypes.Some[golem_core_types.NumericBound](variant677) + default: + panic("unreachable") + } + var option680 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option680 = witTypes.None[string]() + case 1: + value679 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option680 = witTypes.Some[string](value679) + default: + panic("unreachable") + } + + option681 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option676, option678, option680}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU32Type(option681) + + case 9: + var option688 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option688 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option683 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant682 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant682 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant682 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option683 = witTypes.Some[golem_core_types.NumericBound](variant682) + default: + panic("unreachable") + } + var option685 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option685 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant684 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant684 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant684 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant684 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option685 = witTypes.Some[golem_core_types.NumericBound](variant684) + default: + panic("unreachable") + } + var option687 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option687 = witTypes.None[string]() + case 1: + value686 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option687 = witTypes.Some[string](value686) + default: + panic("unreachable") + } + + option688 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option683, option685, option687}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyU64Type(option688) + + case 10: + var option695 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option695 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option690 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant689 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant689 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant689 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option690 = witTypes.Some[golem_core_types.NumericBound](variant689) + default: + panic("unreachable") + } + var option692 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option692 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant691 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant691 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant691 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant691 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option692 = witTypes.Some[golem_core_types.NumericBound](variant691) + default: + panic("unreachable") + } + var option694 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option694 = witTypes.None[string]() + case 1: + value693 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option694 = witTypes.Some[string](value693) + default: + panic("unreachable") + } + + option695 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option690, option692, option694}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyF32Type(option695) + + case 11: + var option702 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option702 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option697 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant696 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant696 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant696 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option697 = witTypes.Some[golem_core_types.NumericBound](variant696) + default: + panic("unreachable") + } + var option699 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option699 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant698 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant698 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant698 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant698 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option699 = witTypes.Some[golem_core_types.NumericBound](variant698) + default: + panic("unreachable") + } + var option701 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option701 = witTypes.None[string]() + case 1: + value700 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option701 = witTypes.Some[string](value700) + default: + panic("unreachable") + } + + option702 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option697, option699, option701}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyF64Type(option702) + + case 12: + + variant796 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant796 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result715 := 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)) + value703 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option705 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option705 = witTypes.None[string]() + case 1: + value704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option705 = witTypes.Some[string](value704) + default: + panic("unreachable") + } + result707 := 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)) + 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) + } + + result709 := 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)) + value708 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result709 = append(result709, value708) + } + + var option711 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option711 = witTypes.None[string]() + case 1: + value710 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option711 = witTypes.Some[string](value710) + default: + panic("unreachable") + } + var option714 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option714 = witTypes.None[golem_core_types.Role]() + case 1: + var variant713 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant713 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant713 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant713 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value712 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant713 = golem_core_types.MakeRoleOther(value712) + + default: + panic("unreachable") + } + + option714 = witTypes.Some[golem_core_types.Role](variant713) + default: + panic("unreachable") + } + + result715 = append(result715, golem_core_types.NamedFieldType{value703, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option705, result707, result709, option711, option714}}) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyRecordType(result715) + + case 15: + result729 := 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)) + value716 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option717 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option717 = witTypes.None[int32]() + case 1: + + option717 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option719 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option719 = witTypes.None[string]() + case 1: + value718 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option719 = witTypes.Some[string](value718) + default: + panic("unreachable") + } + result721 := 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)) + 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) + } + + result723 := 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)) + value722 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result723 = append(result723, value722) + } + + var option725 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option725 = witTypes.None[string]() + case 1: + value724 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option725 = witTypes.Some[string](value724) + default: + panic("unreachable") + } + var option728 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option728 = witTypes.None[golem_core_types.Role]() + case 1: + var variant727 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant727 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant727 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant727 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value726 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant727 = golem_core_types.MakeRoleOther(value726) + + default: + panic("unreachable") + } + + option728 = witTypes.Some[golem_core_types.Role](variant727) + default: + panic("unreachable") + } + + result729 = append(result729, golem_core_types.VariantCaseType{value716, option717, golem_core_types.MetadataEnvelope{option719, result721, result723, option725, option728}}) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyVariantType(result729) + + case 16: + 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) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyEnumType(result731) + + case 17: + result733 := 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)) + value732 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result733 = append(result733, value732) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyFlagsType(result733) + + case 18: + result734 := 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) + + result734 = append(result734, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyTupleType(result734) + + case 19: + + variant796 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant796 = 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: + + variant796 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant796 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option735 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option735 = witTypes.None[int32]() + case 1: + + option735 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option736 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option736 = witTypes.None[int32]() + case 1: + + option736 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option735, option736}) + + case 24: + var option739 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option739 = witTypes.None[[]string]() + case 1: + result738 := 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)) + 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) + } + + option739 = witTypes.Some[[]string](result738) + default: + panic("unreachable") + } + var option740 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option740 = witTypes.None[uint32]() + case 1: + + option740 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option741 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option741 = witTypes.None[uint32]() + case 1: + + option741 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option743 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option743 = witTypes.None[string]() + case 1: + value742 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option743 = witTypes.Some[string](value742) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option739, option740, option741, option743}) + + case 25: + var option746 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option746 = witTypes.None[[]string]() + case 1: + result745 := 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)) + value744 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result745 = append(result745, value744) + } + + option746 = witTypes.Some[[]string](result745) + default: + panic("unreachable") + } + var option747 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option747 = witTypes.None[uint32]() + case 1: + + option747 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option748 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option748 = witTypes.None[uint32]() + case 1: + + option748 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option746, option747, option748}) + + case 26: + var option751 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option751 = witTypes.None[[]string]() + case 1: + result750 := 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)) + value749 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result750 = append(result750, value749) + } + + option751 = witTypes.Some[[]string](result750) + default: + panic("unreachable") + } + var option754 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option754 = witTypes.None[[]string]() + case 1: + result753 := 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)) + 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") + } + + variant796 = 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)))), option751, option754}) + + case 27: + var option757 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option757 = witTypes.None[[]string]() + case 1: + result756 := 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)) + value755 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result756 = append(result756, value755) + } + + option757 = witTypes.Some[[]string](result756) + default: + panic("unreachable") + } + var option760 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option760 = witTypes.None[[]string]() + case 1: + result759 := 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)) + value758 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result759 = append(result759, value758) + } + + option760 = witTypes.Some[[]string](result759) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option757, option760}) + + case 28: + + variant796 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant796 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value761 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result763 := 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)) + value762 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result763 = append(result763, value762) + } + + var option765 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option765 = 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))), value764}) + default: + panic("unreachable") + } + var option767 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option767 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value766 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option767 = 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))), value766}) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value761, result763, option765, option767}) + + case 31: + result789 := 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)) + value768 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant777 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value769 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRulePrefix(value769) + + case 1: + value770 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleSuffix(value770) + + case 2: + value771 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleContains(value771) + + case 3: + value772 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleRegex(value772) + + case 4: + value773 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option775 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option775 = witTypes.None[string]() + case 1: + value774 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option775 = witTypes.Some[string](value774) + default: + panic("unreachable") + } + + variant777 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value773, option775}) + + case 5: + value776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant777 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value776) + + default: + panic("unreachable") + } + var option779 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option779 = witTypes.None[string]() + case 1: + value778 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option779 = witTypes.Some[string](value778) + default: + panic("unreachable") + } + result781 := 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)) + 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) + } + + result783 := 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)) + value782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result783 = append(result783, value782) + } + + var option785 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option785 = witTypes.None[string]() + case 1: + value784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option785 = witTypes.Some[string](value784) + default: + panic("unreachable") + } + var option788 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option788 = witTypes.None[golem_core_types.Role]() + case 1: + var variant787 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant787 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant787 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant787 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value786 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant787 = golem_core_types.MakeRoleOther(value786) + + default: + panic("unreachable") + } + + option788 = witTypes.Some[golem_core_types.Role](variant787) + default: + panic("unreachable") + } + + result789 = append(result789, golem_core_types.UnionBranch{value768, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant777, golem_core_types.MetadataEnvelope{option779, result781, result783, option785, option788}}) + } + + variant796 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result789}) + + case 32: + var option791 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option791 = witTypes.None[string]() + case 1: + value790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option791 = witTypes.Some[string](value790) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option791}) + + case 33: + var option793 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option793 = witTypes.None[string]() + case 1: + value792 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option793 = witTypes.Some[string](value792) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option793}) + + case 34: + + variant796 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option794 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option794 = witTypes.None[int32]() + case 1: + + option794 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyFutureType(option794) + + case 36: + var option795 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option795 = witTypes.None[int32]() + case 1: + + option795 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant796 = golem_core_types.MakeSchemaTypeBodyStreamType(option795) + + default: + panic("unreachable") + } + var option798 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option798 = witTypes.None[string]() + case 1: + value797 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option798 = witTypes.Some[string](value797) + default: + panic("unreachable") + } + result800 := 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)) + 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) + } + + result802 := 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)) + value801 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result802 = append(result802, value801) + } + + var option804 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option804 = witTypes.None[string]() + case 1: + value803 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option804 = witTypes.Some[string](value803) + default: + panic("unreachable") + } + var option807 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option807 = witTypes.None[golem_core_types.Role]() + case 1: + var variant806 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant806 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant806 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant806 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value805 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant806 = golem_core_types.MakeRoleOther(value805) + + default: + panic("unreachable") + } + + option807 = witTypes.Some[golem_core_types.Role](variant806) + default: + panic("unreachable") + } + + result808 = append(result808, golem_core_types.SchemaTypeNode{variant796, golem_core_types.MetadataEnvelope{option798, result800, result802, option804, option807}}) + } + + result812 := 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)) + value809 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option811 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option811 = witTypes.None[string]() + case 1: + value810 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option811 = witTypes.Some[string](value810) + default: + panic("unreachable") + } + + result812 = append(result812, golem_core_types.SchemaTypeDef{value809, option811, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result836 := 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 variant835 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant835 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant835 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant835 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant835 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant835 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant835 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant835 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant835 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant835 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant835 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant835 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant835 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value813 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeStringValue(value813) + + case 13: + result814 := 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) + + result814 = append(result814, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeRecordValue(result814) + + case 14: + var option815 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option815 = witTypes.None[int32]() + case 1: + + option815 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option815}) + + case 15: + + variant835 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result816 := 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) + + result816 = append(result816, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant835 = golem_core_types.MakeSchemaValueNodeFlagsValue(result816) + + case 17: + 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))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeTupleValue(result817) + + case 18: + result818 := 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) + + result818 = append(result818, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeListValue(result818) + + case 19: + result819 := 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) + + result819 = append(result819, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant835 = golem_core_types.MakeSchemaValueNodeFixedListValue(result819) + + case 20: + result820 := 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) + + result820 = append(result820, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant835 = golem_core_types.MakeSchemaValueNodeMapValue(result820) + + case 21: + var option821 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option821 = witTypes.None[int32]() + case 1: + + option821 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeOptionValue(option821) + + case 22: + var variant824 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option822 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option822 = witTypes.None[int32]() + case 1: + + option822 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant824 = golem_core_types.MakeResultValuePayloadOkValue(option822) + + case 1: + var option823 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option823 = witTypes.None[int32]() + case 1: + + option823 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant824 = golem_core_types.MakeResultValuePayloadErrValue(option823) + + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeResultValue(variant824) + + case 23: + value825 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option827 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option827 = witTypes.None[string]() + case 1: + value826 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option827 = witTypes.Some[string](value826) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value825, option827}) + + case 24: + value828 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option830 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option830 = witTypes.None[string]() + case 1: + value829 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option830 = witTypes.Some[string](value829) + default: + panic("unreachable") + } + + variant835 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value828, option830}) + + case 25: + value831 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodePathValue(value831) + + case 26: + value832 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeUrlValue(value832) + + case 27: + + variant835 = 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: + + variant835 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value833 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value833}) + + case 30: + value834 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant835 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value834, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant835 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant835 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant835 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result836 = append(result836, variant835) + } + + option837 = witTypes.Some[golem_core_types.TypedSchemaValue](golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result808, result812, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))}, golem_core_types.SchemaValueTree{result836, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}}) + default: + panic("unreachable") + } + + variant2472 = 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))), option837}) + + case 4: + var variant1282 AgentInvocation + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + value838 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + result1014 := 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 variant1002 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1002 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1002 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option845 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option845 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option840 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant839 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant839 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant839 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option840 = witTypes.Some[golem_core_types.NumericBound](variant839) + default: + panic("unreachable") + } + var option842 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option842 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant841 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant841 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant841 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant841 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option842 = witTypes.Some[golem_core_types.NumericBound](variant841) + default: + panic("unreachable") + } + var option844 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option844 = witTypes.None[string]() + case 1: + value843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option844 = witTypes.Some[string](value843) + default: + panic("unreachable") + } + + option845 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option840, option842, option844}) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS8Type(option845) + + case 3: + var option852 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option852 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option847 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant846 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant846 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant846 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option847 = witTypes.Some[golem_core_types.NumericBound](variant846) + default: + panic("unreachable") + } + var option849 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option849 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant848 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant848 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant848 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant848 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option849 = witTypes.Some[golem_core_types.NumericBound](variant848) + default: + panic("unreachable") + } + var option851 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option851 = witTypes.None[string]() + case 1: + value850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option851 = witTypes.Some[string](value850) + default: + panic("unreachable") + } + + option852 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option847, option849, option851}) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS16Type(option852) + + case 4: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS32Type(option859) + + case 5: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyS64Type(option866) + + case 6: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU8Type(option873) + + case 7: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU16Type(option880) + + case 8: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU32Type(option887) + + case 9: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyU64Type(option894) + + case 10: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyF32Type(option901) + + case 11: + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyF64Type(option908) + + case 12: + + variant1002 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1002 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result921 := 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)) + value909 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option911 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option911 = witTypes.None[string]() + case 1: + value910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option911 = witTypes.Some[string](value910) + default: + panic("unreachable") + } + result913 := 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)) + 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) + } + + result915 := 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)) + value914 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result915 = append(result915, value914) + } + + var option917 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option917 = witTypes.None[string]() + case 1: + value916 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option917 = witTypes.Some[string](value916) + default: + panic("unreachable") + } + var option920 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option920 = witTypes.None[golem_core_types.Role]() + case 1: + var variant919 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant919 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant919 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant919 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value918 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant919 = golem_core_types.MakeRoleOther(value918) + + default: + panic("unreachable") + } + + option920 = witTypes.Some[golem_core_types.Role](variant919) + default: + panic("unreachable") + } + + result921 = append(result921, golem_core_types.NamedFieldType{value909, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option911, result913, result915, option917, option920}}) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyRecordType(result921) + + case 15: + result935 := 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)) + value922 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option923 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option923 = witTypes.None[int32]() + case 1: + + option923 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option925 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option925 = witTypes.None[string]() + case 1: + value924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option925 = witTypes.Some[string](value924) + default: + panic("unreachable") + } + result927 := 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)) + 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), (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)) + 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), (8 + 9*4)))) { + case 0: + + option931 = witTypes.None[string]() + case 1: + value930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*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), (8 + 12*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), (8 + 13*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), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*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.VariantCaseType{value922, option923, golem_core_types.MetadataEnvelope{option925, result927, result929, option931, option934}}) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyVariantType(result935) + + case 16: + 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) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyEnumType(result937) + + case 17: + result939 := 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)) + value938 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result939 = append(result939, value938) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyFlagsType(result939) + + case 18: + result940 := 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) + + result940 = append(result940, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyTupleType(result940) + + case 19: + + variant1002 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1002 = 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: + + variant1002 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1002 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option941 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option941 = witTypes.None[int32]() + case 1: + + option941 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option942 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option942 = witTypes.None[int32]() + case 1: + + option942 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option941, option942}) + + case 24: + var option945 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option945 = witTypes.None[[]string]() + case 1: + result944 := 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)) + value943 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result944 = append(result944, value943) + } + + option945 = witTypes.Some[[]string](result944) + default: + panic("unreachable") + } + var option946 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option946 = witTypes.None[uint32]() + case 1: + + option946 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option947 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option947 = witTypes.None[uint32]() + case 1: + + option947 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option949 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option949 = witTypes.None[string]() + case 1: + value948 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option949 = witTypes.Some[string](value948) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option945, option946, option947, option949}) + + case 25: + var option952 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option952 = witTypes.None[[]string]() + case 1: + result951 := 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)) + 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) + } + + option952 = witTypes.Some[[]string](result951) + default: + panic("unreachable") + } + var option953 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option953 = witTypes.None[uint32]() + case 1: + + option953 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option954 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option954 = witTypes.None[uint32]() + case 1: + + option954 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option952, option953, option954}) + + case 26: + var option957 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option957 = witTypes.None[[]string]() + case 1: + result956 := 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)) + value955 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result956 = append(result956, value955) + } + + option957 = witTypes.Some[[]string](result956) + default: + panic("unreachable") + } + var option960 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option960 = witTypes.None[[]string]() + case 1: + result959 := 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)) + value958 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result959 = append(result959, value958) + } + + option960 = witTypes.Some[[]string](result959) + default: + panic("unreachable") + } + + variant1002 = 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)))), option957, option960}) + + case 27: + var option963 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option963 = witTypes.None[[]string]() + case 1: + result962 := 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)) + value961 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result962 = append(result962, value961) + } + + option963 = witTypes.Some[[]string](result962) + default: + panic("unreachable") + } + var option966 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option966 = witTypes.None[[]string]() + case 1: + result965 := 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)) + 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") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option963, option966}) + + case 28: + + variant1002 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1002 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value967 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result969 := 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)) + value968 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result969 = append(result969, value968) + } + + var option971 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option971 = 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))), value970}) + default: + panic("unreachable") + } + var option973 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option973 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value972 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option973 = 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))), value972}) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value967, result969, option971, option973}) + + case 31: + result995 := 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)) + value974 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant983 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value975 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRulePrefix(value975) + + case 1: + value976 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleSuffix(value976) + + case 2: + value977 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleContains(value977) + + case 3: + value978 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleRegex(value978) + + case 4: + value979 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option981 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option981 = witTypes.None[string]() + case 1: + value980 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option981 = witTypes.Some[string](value980) + default: + panic("unreachable") + } + + variant983 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value979, option981}) + + case 5: + value982 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant983 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value982) + + default: + panic("unreachable") + } + var option985 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option985 = witTypes.None[string]() + case 1: + value984 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option985 = witTypes.Some[string](value984) + default: + panic("unreachable") + } + result987 := 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)) + 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) + } + + result989 := 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)) + value988 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result989 = append(result989, value988) + } + + var option991 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option991 = witTypes.None[string]() + case 1: + value990 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option991 = witTypes.Some[string](value990) + default: + panic("unreachable") + } + var option994 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option994 = witTypes.None[golem_core_types.Role]() + case 1: + var variant993 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant993 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant993 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant993 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value992 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant993 = golem_core_types.MakeRoleOther(value992) + + default: + panic("unreachable") + } + + option994 = witTypes.Some[golem_core_types.Role](variant993) + default: + panic("unreachable") + } + + result995 = append(result995, golem_core_types.UnionBranch{value974, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant983, golem_core_types.MetadataEnvelope{option985, result987, result989, option991, option994}}) + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result995}) + + case 32: + var option997 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option997 = witTypes.None[string]() + case 1: + value996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option997 = witTypes.Some[string](value996) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option997}) + + case 33: + var option999 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option999 = witTypes.None[string]() + case 1: + value998 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option999 = witTypes.Some[string](value998) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option999}) + + case 34: + + variant1002 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1000 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1000 = witTypes.None[int32]() + case 1: + + option1000 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyFutureType(option1000) + + case 36: + var option1001 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1001 = witTypes.None[int32]() + case 1: + + option1001 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1002 = golem_core_types.MakeSchemaTypeBodyStreamType(option1001) + + default: + panic("unreachable") + } + var option1004 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1004 = witTypes.None[string]() + case 1: + value1003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1004 = witTypes.Some[string](value1003) + default: + panic("unreachable") + } + result1006 := 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)) + 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) + } + + result1008 := 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)) + value1007 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1008 = append(result1008, value1007) + } + + var option1010 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1010 = witTypes.None[string]() + case 1: + value1009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1010 = witTypes.Some[string](value1009) + default: + panic("unreachable") + } + var option1013 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1013 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1012 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1012 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1012 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1012 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1011 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1012 = golem_core_types.MakeRoleOther(value1011) + + default: + panic("unreachable") + } + + option1013 = witTypes.Some[golem_core_types.Role](variant1012) + default: + panic("unreachable") + } + + result1014 = append(result1014, golem_core_types.SchemaTypeNode{variant1002, golem_core_types.MetadataEnvelope{option1004, result1006, result1008, option1010, option1013}}) + } + + result1018 := 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)) + value1015 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1017 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1017 = witTypes.None[string]() + case 1: + value1016 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1017 = witTypes.Some[string](value1016) + default: + panic("unreachable") + } + + result1018 = append(result1018, golem_core_types.SchemaTypeDef{value1015, option1017, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1042 := 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 variant1041 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1041 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1041 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1041 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1041 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1041 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1041 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1041 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1041 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1041 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1041 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1041 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1041 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1019 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeStringValue(value1019) + + case 13: + result1020 := 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) + + result1020 = append(result1020, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeRecordValue(result1020) + + case 14: + var option1021 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1021 = witTypes.None[int32]() + case 1: + + option1021 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1021}) + + case 15: + + variant1041 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1022 := 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) + + result1022 = append(result1022, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1022) + + case 17: + 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))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeTupleValue(result1023) + + case 18: + result1024 := 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) + + result1024 = append(result1024, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeListValue(result1024) + + case 19: + result1025 := 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) + + result1025 = append(result1025, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1025) + + case 20: + result1026 := 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) + + result1026 = append(result1026, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1041 = golem_core_types.MakeSchemaValueNodeMapValue(result1026) + + case 21: + var option1027 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1027 = witTypes.None[int32]() + case 1: + + option1027 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeOptionValue(option1027) + + case 22: + var variant1030 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1028 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1028 = witTypes.None[int32]() + case 1: + + option1028 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1030 = golem_core_types.MakeResultValuePayloadOkValue(option1028) + + case 1: + var option1029 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1029 = witTypes.None[int32]() + case 1: + + option1029 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1030 = golem_core_types.MakeResultValuePayloadErrValue(option1029) + + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeResultValue(variant1030) + + case 23: + value1031 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1033 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1033 = witTypes.None[string]() + case 1: + value1032 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1033 = witTypes.Some[string](value1032) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1031, option1033}) + + case 24: + value1034 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1036 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1036 = witTypes.None[string]() + case 1: + value1035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1036 = witTypes.Some[string](value1035) + default: + panic("unreachable") + } + + variant1041 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1034, option1036}) + + case 25: + value1037 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodePathValue(value1037) + + case 26: + value1038 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeUrlValue(value1038) + + case 27: + + variant1041 = 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: + + variant1041 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1039 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1039}) + + case 30: + value1040 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1041 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1040, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1041 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1041 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1041 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1042 = append(result1042, variant1041) + } + + value1043 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4)))) + result1045 := 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)) + value1044 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1045 = append(result1045, value1044) + } + + result1057 := 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)) + result1056 := 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 variant1055 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1046 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1048 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1048 = witTypes.None[string]() + case 1: + value1047 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1048 = witTypes.Some[string](value1047) + default: + panic("unreachable") + } + var option1049 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1049 = witTypes.None[uint64]() + case 1: + + option1049 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1053 := 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)) + value1050 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1052 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1051 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1052 = golem_api_context.MakeAttributeValueString(value1051) + + default: + panic("unreachable") + } + + result1053 = append(result1053, golem_api_context.Attribute{value1050, variant1052}) + } + + variant1055 = MakeSpanDataLocalSpan(LocalSpanData{value1046, 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))))}, option1048, option1049, result1053, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1054 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1055 = MakeSpanDataExternalSpan(ExternalSpanData{value1054}) + + default: + panic("unreachable") + } + + result1056 = append(result1056, variant1055) + } + + result1057 = append(result1057, result1056) + } + + variant1282 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value838, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1014, result1018, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))}, golem_core_types.SchemaValueTree{result1042, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))}}, value1043, result1045, result1057}) + + case 1: + value1058 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + value1059 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))) + result1235 := 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 variant1223 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1223 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1223 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1066 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1066 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1061 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1060 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1060 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1060 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1061 = witTypes.Some[golem_core_types.NumericBound](variant1060) + default: + panic("unreachable") + } + var option1063 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1063 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1062 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1062 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1062 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1062 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1063 = witTypes.Some[golem_core_types.NumericBound](variant1062) + default: + panic("unreachable") + } + var option1065 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1065 = witTypes.None[string]() + case 1: + value1064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1065 = witTypes.Some[string](value1064) + default: + panic("unreachable") + } + + option1066 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1061, option1063, option1065}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS8Type(option1066) + + case 3: + var option1073 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1073 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1068 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1067 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1067 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1067 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1068 = witTypes.Some[golem_core_types.NumericBound](variant1067) + default: + panic("unreachable") + } + var option1070 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1070 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1069 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1069 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1069 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1069 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1070 = witTypes.Some[golem_core_types.NumericBound](variant1069) + default: + panic("unreachable") + } + var option1072 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1072 = witTypes.None[string]() + case 1: + value1071 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1072 = witTypes.Some[string](value1071) + default: + panic("unreachable") + } + + option1073 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1068, option1070, option1072}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS16Type(option1073) + + case 4: + var option1080 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1080 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1075 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1074 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1074 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1074 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1075 = witTypes.Some[golem_core_types.NumericBound](variant1074) + default: + panic("unreachable") + } + var option1077 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1077 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1076 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1076 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1076 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1076 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1077 = witTypes.Some[golem_core_types.NumericBound](variant1076) + default: + panic("unreachable") + } + var option1079 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1079 = witTypes.None[string]() + case 1: + value1078 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1079 = witTypes.Some[string](value1078) + default: + panic("unreachable") + } + + option1080 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1075, option1077, option1079}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS32Type(option1080) + + case 5: + var option1087 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1087 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1082 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1081 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1081 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1081 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1082 = witTypes.Some[golem_core_types.NumericBound](variant1081) + default: + panic("unreachable") + } + var option1084 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1084 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1083 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1083 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1083 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1083 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1084 = witTypes.Some[golem_core_types.NumericBound](variant1083) + default: + panic("unreachable") + } + var option1086 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1086 = witTypes.None[string]() + case 1: + value1085 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1086 = witTypes.Some[string](value1085) + default: + panic("unreachable") + } + + option1087 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1082, option1084, option1086}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyS64Type(option1087) + + case 6: + var option1094 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1094 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1089 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1088 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1088 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1088 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1089 = witTypes.Some[golem_core_types.NumericBound](variant1088) + default: + panic("unreachable") + } + var option1091 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1091 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1090 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1090 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1090 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1090 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1091 = witTypes.Some[golem_core_types.NumericBound](variant1090) + default: + panic("unreachable") + } + var option1093 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1093 = witTypes.None[string]() + case 1: + value1092 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1093 = witTypes.Some[string](value1092) + default: + panic("unreachable") + } + + option1094 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1089, option1091, option1093}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU8Type(option1094) + + case 7: + var option1101 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1101 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1096 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1095 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1095 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1095 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1096 = witTypes.Some[golem_core_types.NumericBound](variant1095) + default: + panic("unreachable") + } + var option1098 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1098 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1097 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1097 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1097 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1097 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1098 = witTypes.Some[golem_core_types.NumericBound](variant1097) + default: + panic("unreachable") + } + var option1100 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1100 = witTypes.None[string]() + case 1: + value1099 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1100 = witTypes.Some[string](value1099) + default: + panic("unreachable") + } + + option1101 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1096, option1098, option1100}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU16Type(option1101) + + case 8: + var option1108 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1108 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1103 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1102 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1102 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1102 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1103 = witTypes.Some[golem_core_types.NumericBound](variant1102) + default: + panic("unreachable") + } + var option1105 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1105 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1104 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1104 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1104 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1104 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1105 = witTypes.Some[golem_core_types.NumericBound](variant1104) + default: + panic("unreachable") + } + var option1107 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1107 = witTypes.None[string]() + case 1: + value1106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1107 = witTypes.Some[string](value1106) + default: + panic("unreachable") + } + + option1108 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1103, option1105, option1107}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU32Type(option1108) + + case 9: + var option1115 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1115 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1110 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1109 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1109 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1109 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1110 = witTypes.Some[golem_core_types.NumericBound](variant1109) + default: + panic("unreachable") + } + var option1112 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1112 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1111 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1111 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1111 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1111 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1112 = witTypes.Some[golem_core_types.NumericBound](variant1111) + default: + panic("unreachable") + } + var option1114 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1114 = witTypes.None[string]() + case 1: + value1113 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1114 = witTypes.Some[string](value1113) + default: + panic("unreachable") + } + + option1115 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1110, option1112, option1114}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyU64Type(option1115) + + case 10: + var option1122 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1122 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1117 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1116 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1116 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1116 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1117 = witTypes.Some[golem_core_types.NumericBound](variant1116) + default: + panic("unreachable") + } + var option1119 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1119 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1118 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1118 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1118 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1118 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1119 = witTypes.Some[golem_core_types.NumericBound](variant1118) + default: + panic("unreachable") + } + var option1121 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1121 = witTypes.None[string]() + case 1: + value1120 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1121 = witTypes.Some[string](value1120) + default: + panic("unreachable") + } + + option1122 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1117, option1119, option1121}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyF32Type(option1122) + + case 11: + var option1129 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1129 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1124 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1123 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1123 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1123 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1124 = witTypes.Some[golem_core_types.NumericBound](variant1123) + default: + panic("unreachable") + } + var option1126 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1126 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1125 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1125 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1125 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1125 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1126 = witTypes.Some[golem_core_types.NumericBound](variant1125) + default: + panic("unreachable") + } + var option1128 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1128 = witTypes.None[string]() + case 1: + value1127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1128 = witTypes.Some[string](value1127) + default: + panic("unreachable") + } + + option1129 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1124, option1126, option1128}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyF64Type(option1129) + + case 12: + + variant1223 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1223 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1142 := 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)) + value1130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1132 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1132 = witTypes.None[string]() + case 1: + value1131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1132 = witTypes.Some[string](value1131) + default: + panic("unreachable") + } + result1134 := 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)) + 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) + } + + result1136 := 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)) + value1135 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1136 = append(result1136, value1135) + } + + var option1138 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1138 = witTypes.None[string]() + case 1: + value1137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1138 = witTypes.Some[string](value1137) + default: + panic("unreachable") + } + var option1141 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1141 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1140 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1140 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1140 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1140 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1140 = golem_core_types.MakeRoleOther(value1139) + + default: + panic("unreachable") + } + + option1141 = witTypes.Some[golem_core_types.Role](variant1140) + default: + panic("unreachable") + } + + result1142 = append(result1142, golem_core_types.NamedFieldType{value1130, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1132, result1134, result1136, option1138, option1141}}) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyRecordType(result1142) + + case 15: + result1156 := 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)) + value1143 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1144 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1144 = witTypes.None[int32]() + case 1: + + option1144 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1146 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1146 = witTypes.None[string]() + case 1: + value1145 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1146 = witTypes.Some[string](value1145) + default: + panic("unreachable") + } + result1148 := 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)) + 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) + } + + result1150 := 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)) + value1149 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1150 = append(result1150, value1149) + } + + var option1152 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1152 = witTypes.None[string]() + case 1: + value1151 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1152 = witTypes.Some[string](value1151) + default: + panic("unreachable") + } + var option1155 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1155 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1154 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1154 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1154 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1154 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1154 = golem_core_types.MakeRoleOther(value1153) + + default: + panic("unreachable") + } + + option1155 = witTypes.Some[golem_core_types.Role](variant1154) + default: + panic("unreachable") + } + + result1156 = append(result1156, golem_core_types.VariantCaseType{value1143, option1144, golem_core_types.MetadataEnvelope{option1146, result1148, result1150, option1152, option1155}}) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyVariantType(result1156) + + case 16: + 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) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyEnumType(result1158) + + case 17: + result1160 := 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)) + value1159 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1160 = append(result1160, value1159) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1160) + + case 18: + result1161 := 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) + + result1161 = append(result1161, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyTupleType(result1161) + + case 19: + + variant1223 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1223 = 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: + + variant1223 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1223 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1162 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1162 = witTypes.None[int32]() + case 1: + + option1162 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1163 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1163 = witTypes.None[int32]() + case 1: + + option1163 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1162, option1163}) + + case 24: + var option1166 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1166 = witTypes.None[[]string]() + case 1: + result1165 := 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)) + value1164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1165 = append(result1165, value1164) + } + + option1166 = witTypes.Some[[]string](result1165) + default: + panic("unreachable") + } + var option1167 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1167 = witTypes.None[uint32]() + case 1: + + option1167 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1168 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1168 = witTypes.None[uint32]() + case 1: + + option1168 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1170 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1170 = witTypes.None[string]() + case 1: + value1169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1170 = witTypes.Some[string](value1169) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1166, option1167, option1168, option1170}) + + case 25: + var option1173 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1173 = witTypes.None[[]string]() + case 1: + result1172 := 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)) + value1171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1172 = append(result1172, value1171) + } + + option1173 = witTypes.Some[[]string](result1172) + default: + panic("unreachable") + } + var option1174 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1174 = witTypes.None[uint32]() + case 1: + + option1174 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1175 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1175 = witTypes.None[uint32]() + case 1: + + option1175 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1173, option1174, option1175}) + + case 26: + var option1178 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1178 = witTypes.None[[]string]() + case 1: + result1177 := 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)) + value1176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1177 = append(result1177, value1176) + } + + option1178 = witTypes.Some[[]string](result1177) + default: + panic("unreachable") + } + var option1181 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1181 = witTypes.None[[]string]() + case 1: + result1180 := 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)) + value1179 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1180 = append(result1180, value1179) + } + + option1181 = witTypes.Some[[]string](result1180) + default: + panic("unreachable") + } + + variant1223 = 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)))), option1178, option1181}) + + case 27: + var option1184 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1184 = witTypes.None[[]string]() + case 1: + result1183 := 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)) + value1182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1183 = append(result1183, value1182) + } + + option1184 = witTypes.Some[[]string](result1183) + default: + panic("unreachable") + } + var option1187 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1187 = witTypes.None[[]string]() + case 1: + result1186 := 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)) + value1185 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1186 = append(result1186, value1185) + } + + option1187 = witTypes.Some[[]string](result1186) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1184, option1187}) + + case 28: + + variant1223 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1223 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1188 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1190 := 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)) + value1189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1190 = append(result1190, value1189) + } + + var option1192 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1192 = 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))), value1191}) + default: + panic("unreachable") + } + var option1194 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1194 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1194 = 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))), value1193}) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1188, result1190, option1192, option1194}) + + case 31: + result1216 := 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)) + value1195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1204 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRulePrefix(value1196) + + case 1: + value1197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleSuffix(value1197) + + case 2: + value1198 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleContains(value1198) + + case 3: + value1199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleRegex(value1199) + + case 4: + value1200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1202 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1202 = witTypes.None[string]() + case 1: + value1201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1202 = witTypes.Some[string](value1201) + default: + panic("unreachable") + } + + variant1204 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1200, option1202}) + + case 5: + value1203 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1204 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1203) + + default: + panic("unreachable") + } + var option1206 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1206 = witTypes.None[string]() + case 1: + value1205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1206 = witTypes.Some[string](value1205) + default: + panic("unreachable") + } + result1208 := 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)) + 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) + } + + result1210 := 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)) + value1209 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1210 = append(result1210, value1209) + } + + var option1212 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1212 = witTypes.None[string]() + case 1: + value1211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1212 = witTypes.Some[string](value1211) + default: + panic("unreachable") + } + var option1215 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1215 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1214 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1214 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1214 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1214 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1214 = golem_core_types.MakeRoleOther(value1213) + + default: + panic("unreachable") + } + + option1215 = witTypes.Some[golem_core_types.Role](variant1214) + default: + panic("unreachable") + } + + result1216 = append(result1216, golem_core_types.UnionBranch{value1195, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1204, golem_core_types.MetadataEnvelope{option1206, result1208, result1210, option1212, option1215}}) + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1216}) + + case 32: + var option1218 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1218 = witTypes.None[string]() + case 1: + value1217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1218 = witTypes.Some[string](value1217) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1218}) + + case 33: + var option1220 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1220 = witTypes.None[string]() + case 1: + value1219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1220 = witTypes.Some[string](value1219) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1220}) + + case 34: + + variant1223 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyFutureType(option1221) + + case 36: + var option1222 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1222 = witTypes.None[int32]() + case 1: + + option1222 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1223 = golem_core_types.MakeSchemaTypeBodyStreamType(option1222) + + default: + panic("unreachable") + } + var option1225 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1225 = witTypes.None[string]() + case 1: + value1224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1225 = witTypes.Some[string](value1224) + default: + panic("unreachable") + } + result1227 := 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)) + 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) + } + + result1229 := 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)) + value1228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1229 = append(result1229, value1228) + } + + var option1231 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1231 = witTypes.None[string]() + case 1: + value1230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1231 = witTypes.Some[string](value1230) + default: + panic("unreachable") + } + var option1234 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1234 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1233 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1233 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1233 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1233 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1233 = golem_core_types.MakeRoleOther(value1232) + + default: + panic("unreachable") + } + + option1234 = witTypes.Some[golem_core_types.Role](variant1233) + default: + panic("unreachable") + } + + result1235 = append(result1235, golem_core_types.SchemaTypeNode{variant1223, golem_core_types.MetadataEnvelope{option1225, result1227, result1229, option1231, option1234}}) + } + + result1239 := 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)) + value1236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1238 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1238 = witTypes.None[string]() + case 1: + value1237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1238 = witTypes.Some[string](value1237) + default: + panic("unreachable") + } + + result1239 = append(result1239, golem_core_types.SchemaTypeDef{value1236, option1238, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1263 := 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 variant1262 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1262 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1262 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1262 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1262 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1262 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1262 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1262 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1262 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1262 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1262 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1262 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1262 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1240 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeStringValue(value1240) + + case 13: + result1241 := 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) + + result1241 = append(result1241, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeRecordValue(result1241) + + case 14: + var option1242 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1242 = witTypes.None[int32]() + case 1: + + option1242 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1242}) + + case 15: + + variant1262 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1243 := 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) + + result1243 = append(result1243, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1243) + + case 17: + 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))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeTupleValue(result1244) + + case 18: + 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))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeListValue(result1245) + + case 19: + result1246 := 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) + + result1246 = append(result1246, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1246) + + case 20: + result1247 := 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) + + result1247 = append(result1247, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1262 = golem_core_types.MakeSchemaValueNodeMapValue(result1247) + + case 21: + var option1248 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1248 = witTypes.None[int32]() + case 1: + + option1248 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeOptionValue(option1248) + + case 22: + var variant1251 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant1251 = golem_core_types.MakeResultValuePayloadOkValue(option1249) + + case 1: + var option1250 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1250 = witTypes.None[int32]() + case 1: + + option1250 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1251 = golem_core_types.MakeResultValuePayloadErrValue(option1250) + + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeResultValue(variant1251) + + case 23: + value1252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1254 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1254 = witTypes.None[string]() + case 1: + value1253 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1254 = witTypes.Some[string](value1253) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1252, option1254}) + + case 24: + value1255 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1257 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1257 = witTypes.None[string]() + case 1: + value1256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1257 = witTypes.Some[string](value1256) + default: + panic("unreachable") + } + + variant1262 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1255, option1257}) + + case 25: + value1258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodePathValue(value1258) + + case 26: + value1259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeUrlValue(value1259) + + case 27: + + variant1262 = 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: + + variant1262 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1260}) + + case 30: + value1261 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1262 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1261, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1262 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1262 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1262 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1263 = append(result1263, variant1262) + } + + value1264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4)))) + result1266 := 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)) + value1265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1266 = append(result1266, value1265) + } + + result1278 := 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)) + result1277 := 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 variant1276 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1267 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1269 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1269 = witTypes.None[string]() + case 1: + value1268 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1269 = witTypes.Some[string](value1268) + default: + panic("unreachable") + } + var option1270 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1270 = witTypes.None[uint64]() + case 1: + + option1270 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1274 := 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)) + value1271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1273 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1272 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1273 = golem_api_context.MakeAttributeValueString(value1272) + + default: + panic("unreachable") + } + + result1274 = append(result1274, golem_api_context.Attribute{value1271, variant1273}) + } + + variant1276 = MakeSpanDataLocalSpan(LocalSpanData{value1267, 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))))}, option1269, option1270, result1274, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1275 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1276 = MakeSpanDataExternalSpan(ExternalSpanData{value1275}) + + default: + panic("unreachable") + } + + result1277 = append(result1277, variant1276) + } + + result1278 = append(result1278, result1277) + } + + variant1282 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1058, value1059, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1235, result1239, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}, golem_core_types.SchemaValueTree{result1263, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4)))}}, value1264, result1266, result1278}) + + case 2: + + variant1282 = MakeAgentInvocationSaveSnapshot() + + case 3: + value1279 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + value1280 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))) + + variant1282 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value1279, value1280}}) + + case 4: + value1281 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + + variant1282 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value1281}) + + case 5: + + variant1282 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}) + + default: + panic("unreachable") + } + + variant2472 = 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)))}, variant1282}) + + case 5: + var variant1697 AgentInvocationResult + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + result1458 := 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 variant1446 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1446 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1446 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1289 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1289 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1284 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1283 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1283 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1283 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1284 = witTypes.Some[golem_core_types.NumericBound](variant1283) + default: + panic("unreachable") + } + var option1286 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1286 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1285 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1285 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1285 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1285 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1286 = witTypes.Some[golem_core_types.NumericBound](variant1285) + default: + panic("unreachable") + } + var option1288 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1288 = witTypes.None[string]() + case 1: + value1287 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1288 = witTypes.Some[string](value1287) + default: + panic("unreachable") + } + + option1289 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1284, option1286, option1288}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS8Type(option1289) + + case 3: + var option1296 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1296 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1291 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1290 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1290 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1290 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1291 = witTypes.Some[golem_core_types.NumericBound](variant1290) + default: + panic("unreachable") + } + var option1293 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1293 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1292 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1292 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1292 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1292 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1293 = witTypes.Some[golem_core_types.NumericBound](variant1292) + default: + panic("unreachable") + } + var option1295 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1295 = witTypes.None[string]() + case 1: + value1294 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1295 = witTypes.Some[string](value1294) + default: + panic("unreachable") + } + + option1296 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1291, option1293, option1295}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS16Type(option1296) + + case 4: + var option1303 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1303 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1298 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1297 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1297 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1297 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1298 = witTypes.Some[golem_core_types.NumericBound](variant1297) + default: + panic("unreachable") + } + var option1300 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1300 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1299 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1299 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1299 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1299 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1300 = witTypes.Some[golem_core_types.NumericBound](variant1299) + default: + panic("unreachable") + } + var option1302 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1302 = witTypes.None[string]() + case 1: + value1301 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1302 = witTypes.Some[string](value1301) + default: + panic("unreachable") + } + + option1303 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1298, option1300, option1302}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS32Type(option1303) + + case 5: + var option1310 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1310 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1305 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1304 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1304 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1304 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1305 = witTypes.Some[golem_core_types.NumericBound](variant1304) + default: + panic("unreachable") + } + var option1307 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1307 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1306 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1306 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1306 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1306 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1307 = witTypes.Some[golem_core_types.NumericBound](variant1306) + default: + panic("unreachable") + } + var option1309 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1309 = witTypes.None[string]() + case 1: + value1308 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1309 = witTypes.Some[string](value1308) + default: + panic("unreachable") + } + + option1310 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1305, option1307, option1309}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyS64Type(option1310) + + case 6: + var option1317 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1317 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1312 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1311 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1311 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1311 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1312 = witTypes.Some[golem_core_types.NumericBound](variant1311) + default: + panic("unreachable") + } + var option1314 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1314 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1313 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1313 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1313 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1313 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1314 = witTypes.Some[golem_core_types.NumericBound](variant1313) + default: + panic("unreachable") + } + var option1316 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1316 = witTypes.None[string]() + case 1: + value1315 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1316 = witTypes.Some[string](value1315) + default: + panic("unreachable") + } + + option1317 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1312, option1314, option1316}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU8Type(option1317) + + case 7: + var option1324 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1324 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1319 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1318 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1318 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1318 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1319 = witTypes.Some[golem_core_types.NumericBound](variant1318) + default: + panic("unreachable") + } + var option1321 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1321 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1320 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1320 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1320 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1320 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1321 = witTypes.Some[golem_core_types.NumericBound](variant1320) + default: + panic("unreachable") + } + var option1323 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1323 = witTypes.None[string]() + case 1: + value1322 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1323 = witTypes.Some[string](value1322) + default: + panic("unreachable") + } + + option1324 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1319, option1321, option1323}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU16Type(option1324) + + case 8: + var option1331 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1331 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1326 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1325 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1325 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1325 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1326 = witTypes.Some[golem_core_types.NumericBound](variant1325) + default: + panic("unreachable") + } + var option1328 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1328 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1327 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1327 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1327 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1327 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1328 = witTypes.Some[golem_core_types.NumericBound](variant1327) + default: + panic("unreachable") + } + var option1330 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1330 = witTypes.None[string]() + case 1: + value1329 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1330 = witTypes.Some[string](value1329) + default: + panic("unreachable") + } + + option1331 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1326, option1328, option1330}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU32Type(option1331) + + case 9: + var option1338 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1338 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1333 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1332 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1332 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1332 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1333 = witTypes.Some[golem_core_types.NumericBound](variant1332) + default: + panic("unreachable") + } + var option1335 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1335 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1334 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1334 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1334 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1334 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1335 = witTypes.Some[golem_core_types.NumericBound](variant1334) + default: + panic("unreachable") + } + var option1337 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1337 = witTypes.None[string]() + case 1: + value1336 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1337 = witTypes.Some[string](value1336) + default: + panic("unreachable") + } + + option1338 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1333, option1335, option1337}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyU64Type(option1338) + + case 10: + var option1345 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1345 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1340 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1339 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1339 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1339 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1340 = witTypes.Some[golem_core_types.NumericBound](variant1339) + default: + panic("unreachable") + } + var option1342 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1342 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1341 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1341 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1341 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1341 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1342 = witTypes.Some[golem_core_types.NumericBound](variant1341) + default: + panic("unreachable") + } + var option1344 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1344 = witTypes.None[string]() + case 1: + value1343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1344 = witTypes.Some[string](value1343) + default: + panic("unreachable") + } + + option1345 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1340, option1342, option1344}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyF32Type(option1345) + + case 11: + var option1352 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1352 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1347 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1346 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1346 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1346 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1347 = witTypes.Some[golem_core_types.NumericBound](variant1346) + default: + panic("unreachable") + } + var option1349 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1349 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1348 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1348 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1348 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1348 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1349 = witTypes.Some[golem_core_types.NumericBound](variant1348) + default: + panic("unreachable") + } + var option1351 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1351 = witTypes.None[string]() + case 1: + value1350 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1351 = witTypes.Some[string](value1350) + default: + panic("unreachable") + } + + option1352 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1347, option1349, option1351}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyF64Type(option1352) + + case 12: + + variant1446 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1446 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1365 := 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)) + value1353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1355 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1355 = witTypes.None[string]() + case 1: + value1354 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1355 = witTypes.Some[string](value1354) + default: + panic("unreachable") + } + result1357 := 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)) + 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) + } + + result1359 := 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)) + value1358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1359 = append(result1359, value1358) + } + + var option1361 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1361 = witTypes.None[string]() + case 1: + value1360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1361 = witTypes.Some[string](value1360) + default: + panic("unreachable") + } + var option1364 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1364 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1363 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1363 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1363 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1363 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1362 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1363 = golem_core_types.MakeRoleOther(value1362) + + default: + panic("unreachable") + } + + option1364 = witTypes.Some[golem_core_types.Role](variant1363) + default: + panic("unreachable") + } + + result1365 = append(result1365, golem_core_types.NamedFieldType{value1353, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1355, result1357, result1359, option1361, option1364}}) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyRecordType(result1365) + + case 15: + result1379 := 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)) + value1366 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1367 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1367 = witTypes.None[int32]() + case 1: + + option1367 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1369 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1369 = witTypes.None[string]() + case 1: + value1368 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1369 = witTypes.Some[string](value1368) + default: + panic("unreachable") + } + result1371 := 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)) + 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) + } + + result1373 := 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)) + value1372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1373 = append(result1373, value1372) + } + + var option1375 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1375 = witTypes.None[string]() + case 1: + value1374 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1375 = witTypes.Some[string](value1374) + default: + panic("unreachable") + } + var option1378 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1378 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1377 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1377 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1377 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1377 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1376 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1377 = golem_core_types.MakeRoleOther(value1376) + + default: + panic("unreachable") + } + + option1378 = witTypes.Some[golem_core_types.Role](variant1377) + default: + panic("unreachable") + } + + result1379 = append(result1379, golem_core_types.VariantCaseType{value1366, option1367, golem_core_types.MetadataEnvelope{option1369, result1371, result1373, option1375, option1378}}) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyVariantType(result1379) + + case 16: + 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) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyEnumType(result1381) + + case 17: + result1383 := 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)) + value1382 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1383 = append(result1383, value1382) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1383) + + case 18: + result1384 := 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) + + result1384 = append(result1384, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyTupleType(result1384) + + case 19: + + variant1446 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1446 = 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: + + variant1446 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1446 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1385 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1385 = witTypes.None[int32]() + case 1: + + option1385 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1386 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1386 = witTypes.None[int32]() + case 1: + + option1386 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1385, option1386}) + + case 24: + var option1389 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1389 = witTypes.None[[]string]() + case 1: + result1388 := 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)) + value1387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1388 = append(result1388, value1387) + } + + option1389 = witTypes.Some[[]string](result1388) + default: + panic("unreachable") + } + var option1390 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1390 = witTypes.None[uint32]() + case 1: + + option1390 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1391 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1391 = witTypes.None[uint32]() + case 1: + + option1391 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1393 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1393 = witTypes.None[string]() + case 1: + value1392 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1393 = witTypes.Some[string](value1392) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1389, option1390, option1391, option1393}) + + case 25: + var option1396 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1396 = witTypes.None[[]string]() + case 1: + result1395 := 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)) + value1394 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1395 = append(result1395, value1394) + } + + option1396 = witTypes.Some[[]string](result1395) + default: + panic("unreachable") + } + var option1397 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1397 = witTypes.None[uint32]() + case 1: + + option1397 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1398 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1398 = witTypes.None[uint32]() + case 1: + + option1398 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1396, option1397, option1398}) + + case 26: + var option1401 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1401 = witTypes.None[[]string]() + case 1: + result1400 := 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)) + 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") + } + var option1404 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1404 = witTypes.None[[]string]() + case 1: + result1403 := 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)) + 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") + } + + variant1446 = 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)))), option1401, option1404}) + + case 27: + var option1407 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1407 = witTypes.None[[]string]() + case 1: + result1406 := 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)) + 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") + } + var option1410 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1410 = witTypes.None[[]string]() + case 1: + result1409 := 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)) + value1408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1409 = append(result1409, value1408) + } + + option1410 = witTypes.Some[[]string](result1409) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1407, option1410}) + + case 28: + + variant1446 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1446 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1413 := 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)) + value1412 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1413 = append(result1413, value1412) + } + + var option1415 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1415 = 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))), value1414}) + default: + panic("unreachable") + } + var option1417 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1417 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1416 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1417 = 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))), value1416}) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1411, result1413, option1415, option1417}) + + case 31: + result1439 := 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)) + value1418 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1427 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRulePrefix(value1419) + + case 1: + value1420 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleSuffix(value1420) + + case 2: + value1421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleContains(value1421) + + case 3: + value1422 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleRegex(value1422) + + case 4: + value1423 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1425 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1425 = witTypes.None[string]() + case 1: + value1424 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1425 = witTypes.Some[string](value1424) + default: + panic("unreachable") + } + + variant1427 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1423, option1425}) + + case 5: + value1426 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1427 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1426) + + default: + panic("unreachable") + } + var option1429 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1429 = witTypes.None[string]() + case 1: + value1428 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1429 = witTypes.Some[string](value1428) + default: + panic("unreachable") + } + result1431 := 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)) + 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) + } + + result1433 := 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)) + value1432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1433 = append(result1433, value1432) + } + + var option1435 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1435 = witTypes.None[string]() + case 1: + value1434 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1435 = witTypes.Some[string](value1434) + default: + panic("unreachable") + } + var option1438 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1438 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1437 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1437 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1437 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1437 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1436 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1437 = golem_core_types.MakeRoleOther(value1436) + + default: + panic("unreachable") + } + + option1438 = witTypes.Some[golem_core_types.Role](variant1437) + default: + panic("unreachable") + } + + result1439 = append(result1439, golem_core_types.UnionBranch{value1418, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1427, golem_core_types.MetadataEnvelope{option1429, result1431, result1433, option1435, option1438}}) + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1439}) + + case 32: + var option1441 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1441 = witTypes.None[string]() + case 1: + value1440 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1441 = witTypes.Some[string](value1440) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1441}) + + case 33: + var option1443 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1443 = witTypes.None[string]() + case 1: + value1442 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1443 = witTypes.Some[string](value1442) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1443}) + + case 34: + + variant1446 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1444 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1444 = witTypes.None[int32]() + case 1: + + option1444 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyFutureType(option1444) + + case 36: + var option1445 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1445 = witTypes.None[int32]() + case 1: + + option1445 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1446 = golem_core_types.MakeSchemaTypeBodyStreamType(option1445) + + default: + panic("unreachable") + } + var option1448 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1448 = witTypes.None[string]() + case 1: + value1447 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1448 = witTypes.Some[string](value1447) + default: + panic("unreachable") + } + result1450 := 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)) + 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) + } + + result1452 := 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)) + value1451 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1452 = append(result1452, value1451) + } + + var option1454 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1454 = witTypes.None[string]() + case 1: + value1453 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1454 = witTypes.Some[string](value1453) + default: + panic("unreachable") + } + var option1457 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1457 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1456 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1456 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1456 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1456 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1455 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1456 = golem_core_types.MakeRoleOther(value1455) + + default: + panic("unreachable") + } + + option1457 = witTypes.Some[golem_core_types.Role](variant1456) + default: + panic("unreachable") + } + + result1458 = append(result1458, golem_core_types.SchemaTypeNode{variant1446, golem_core_types.MetadataEnvelope{option1448, result1450, result1452, option1454, option1457}}) + } + + result1462 := 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)) + value1459 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1461 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1461 = witTypes.None[string]() + case 1: + value1460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1461 = witTypes.Some[string](value1460) + default: + panic("unreachable") + } + + result1462 = append(result1462, golem_core_types.SchemaTypeDef{value1459, option1461, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1486 := 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 variant1485 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1485 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1485 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1485 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1485 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1485 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1485 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1485 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1485 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1485 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1485 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1485 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1485 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1463 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeStringValue(value1463) + + case 13: + 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))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeRecordValue(result1464) + + case 14: + var option1465 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1465 = witTypes.None[int32]() + case 1: + + option1465 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1465}) + + case 15: + + variant1485 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1466 := 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) + + result1466 = append(result1466, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1466) + + case 17: + 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))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeTupleValue(result1467) + + case 18: + result1468 := 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) + + result1468 = append(result1468, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeListValue(result1468) + + case 19: + result1469 := 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) + + result1469 = append(result1469, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1469) + + case 20: + result1470 := 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) + + result1470 = append(result1470, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1485 = golem_core_types.MakeSchemaValueNodeMapValue(result1470) + + case 21: + var option1471 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1471 = witTypes.None[int32]() + case 1: + + option1471 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeOptionValue(option1471) + + case 22: + var variant1474 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1472 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1472 = witTypes.None[int32]() + case 1: + + option1472 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1474 = golem_core_types.MakeResultValuePayloadOkValue(option1472) + + case 1: + var option1473 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1473 = witTypes.None[int32]() + case 1: + + option1473 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1474 = golem_core_types.MakeResultValuePayloadErrValue(option1473) + + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeResultValue(variant1474) + + case 23: + value1475 := unsafe.String((*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") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1475, option1477}) + + case 24: + value1478 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1480 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1480 = witTypes.None[string]() + case 1: + value1479 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1480 = witTypes.Some[string](value1479) + default: + panic("unreachable") + } + + variant1485 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1478, option1480}) + + case 25: + value1481 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodePathValue(value1481) + + case 26: + value1482 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeUrlValue(value1482) + + case 27: + + variant1485 = 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: + + variant1485 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1483 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1483}) + + case 30: + value1484 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1485 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1484, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1485 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1485 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1485 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1486 = append(result1486, variant1485) + } + + variant1697 = MakeAgentInvocationResultAgentInitialization(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1458, result1462, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result1486, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}}) + + case 1: + result1662 := 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 variant1650 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1650 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1650 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1493 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1493 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1488 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1487 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1487 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1487 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1488 = witTypes.Some[golem_core_types.NumericBound](variant1487) + default: + panic("unreachable") + } + var option1490 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1490 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1489 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1489 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1489 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1489 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1490 = witTypes.Some[golem_core_types.NumericBound](variant1489) + default: + panic("unreachable") + } + var option1492 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1492 = witTypes.None[string]() + case 1: + value1491 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1492 = witTypes.Some[string](value1491) + default: + panic("unreachable") + } + + option1493 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1488, option1490, option1492}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS8Type(option1493) + + case 3: + var option1500 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1500 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1495 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1494 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1494 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1494 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1495 = witTypes.Some[golem_core_types.NumericBound](variant1494) + default: + panic("unreachable") + } + var option1497 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1497 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1496 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1496 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1496 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1496 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1497 = witTypes.Some[golem_core_types.NumericBound](variant1496) + default: + panic("unreachable") + } + var option1499 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1499 = witTypes.None[string]() + case 1: + value1498 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1499 = witTypes.Some[string](value1498) + default: + panic("unreachable") + } + + option1500 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1495, option1497, option1499}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS16Type(option1500) + + case 4: + var option1507 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1507 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1502 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1501 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1501 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1501 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1502 = witTypes.Some[golem_core_types.NumericBound](variant1501) + default: + panic("unreachable") + } + var option1504 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1503 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1503 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1503 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1504 = witTypes.Some[golem_core_types.NumericBound](variant1503) + default: + panic("unreachable") + } + var option1506 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1506 = witTypes.None[string]() + case 1: + value1505 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1506 = witTypes.Some[string](value1505) + default: + panic("unreachable") + } + + option1507 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1502, option1504, option1506}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS32Type(option1507) + + case 5: + var option1514 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1514 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1509 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1508 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1508 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1508 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1509 = witTypes.Some[golem_core_types.NumericBound](variant1508) + default: + panic("unreachable") + } + var option1511 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1510 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1510 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1510 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1511 = witTypes.Some[golem_core_types.NumericBound](variant1510) + default: + panic("unreachable") + } + var option1513 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1513 = witTypes.None[string]() + case 1: + value1512 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1513 = witTypes.Some[string](value1512) + default: + panic("unreachable") + } + + option1514 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1509, option1511, option1513}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyS64Type(option1514) + + case 6: + var option1521 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1521 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1516 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1515 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1515 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1515 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1516 = witTypes.Some[golem_core_types.NumericBound](variant1515) + default: + panic("unreachable") + } + var option1518 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1517 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1517 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1517 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1518 = witTypes.Some[golem_core_types.NumericBound](variant1517) + default: + panic("unreachable") + } + var option1520 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1520 = witTypes.None[string]() + case 1: + value1519 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1520 = witTypes.Some[string](value1519) + default: + panic("unreachable") + } + + option1521 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1516, option1518, option1520}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU8Type(option1521) + + case 7: + var option1528 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1528 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1523 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1522 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1522 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1522 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1523 = witTypes.Some[golem_core_types.NumericBound](variant1522) + default: + panic("unreachable") + } + var option1525 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1524 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1524 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1524 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1525 = witTypes.Some[golem_core_types.NumericBound](variant1524) + default: + panic("unreachable") + } + var option1527 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1527 = witTypes.None[string]() + case 1: + value1526 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1527 = witTypes.Some[string](value1526) + default: + panic("unreachable") + } + + option1528 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1523, option1525, option1527}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU16Type(option1528) + + case 8: + var option1535 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1535 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1530 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1529 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1529 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1529 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1530 = witTypes.Some[golem_core_types.NumericBound](variant1529) + default: + panic("unreachable") + } + var option1532 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1531 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1531 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1531 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1532 = witTypes.Some[golem_core_types.NumericBound](variant1531) + default: + panic("unreachable") + } + var option1534 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1534 = witTypes.None[string]() + case 1: + value1533 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1534 = witTypes.Some[string](value1533) + default: + panic("unreachable") + } + + option1535 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1530, option1532, option1534}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU32Type(option1535) + + case 9: + var option1542 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1542 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1537 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1536 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1536 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1536 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1537 = witTypes.Some[golem_core_types.NumericBound](variant1536) + default: + panic("unreachable") + } + var option1539 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1538 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1538 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1538 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1539 = witTypes.Some[golem_core_types.NumericBound](variant1538) + default: + panic("unreachable") + } + var option1541 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1541 = witTypes.None[string]() + case 1: + value1540 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1541 = witTypes.Some[string](value1540) + default: + panic("unreachable") + } + + option1542 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1537, option1539, option1541}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyU64Type(option1542) + + case 10: + var option1549 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1549 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1544 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1543 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1543 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1543 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1544 = witTypes.Some[golem_core_types.NumericBound](variant1543) + default: + panic("unreachable") + } + var option1546 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1545 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1545 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1545 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1546 = witTypes.Some[golem_core_types.NumericBound](variant1545) + default: + panic("unreachable") + } + var option1548 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1548 = witTypes.None[string]() + case 1: + value1547 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1548 = witTypes.Some[string](value1547) + default: + panic("unreachable") + } + + option1549 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1544, option1546, option1548}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyF32Type(option1549) + + case 11: + var option1556 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1556 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1551 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1550 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1550 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1550 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1551 = witTypes.Some[golem_core_types.NumericBound](variant1550) + default: + panic("unreachable") + } + var option1553 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1552 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1552 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1552 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1553 = witTypes.Some[golem_core_types.NumericBound](variant1552) + default: + panic("unreachable") + } + var option1555 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1555 = witTypes.None[string]() + case 1: + value1554 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1555 = witTypes.Some[string](value1554) + default: + panic("unreachable") + } + + option1556 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1551, option1553, option1555}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyF64Type(option1556) + + case 12: + + variant1650 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1650 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1569 := 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)) + value1557 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1559 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1559 = witTypes.None[string]() + case 1: + value1558 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1559 = witTypes.Some[string](value1558) + default: + panic("unreachable") + } + result1561 := 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)) + 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) + } + + result1563 := 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)) + value1562 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1563 = append(result1563, value1562) + } + + var option1565 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1565 = witTypes.None[string]() + case 1: + value1564 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1565 = witTypes.Some[string](value1564) + default: + panic("unreachable") + } + var option1568 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1568 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1567 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1567 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1567 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1567 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1566 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1567 = golem_core_types.MakeRoleOther(value1566) + + default: + panic("unreachable") + } + + option1568 = witTypes.Some[golem_core_types.Role](variant1567) + default: + panic("unreachable") + } + + result1569 = append(result1569, golem_core_types.NamedFieldType{value1557, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1559, result1561, result1563, option1565, option1568}}) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyRecordType(result1569) + + case 15: + result1583 := 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)) + value1570 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1571 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1571 = witTypes.None[int32]() + case 1: + + option1571 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1573 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1573 = witTypes.None[string]() + case 1: + value1572 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1573 = witTypes.Some[string](value1572) + default: + panic("unreachable") + } + result1575 := 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)) + 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) + } + + result1577 := 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)) + 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) + } + + var option1579 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1579 = witTypes.None[string]() + case 1: + value1578 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1579 = witTypes.Some[string](value1578) + default: + panic("unreachable") + } + var option1582 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1582 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1581 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1581 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1581 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1581 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1580 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1581 = golem_core_types.MakeRoleOther(value1580) + + default: + panic("unreachable") + } + + option1582 = witTypes.Some[golem_core_types.Role](variant1581) + default: + panic("unreachable") + } + + result1583 = append(result1583, golem_core_types.VariantCaseType{value1570, option1571, golem_core_types.MetadataEnvelope{option1573, result1575, result1577, option1579, option1582}}) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyVariantType(result1583) + + case 16: + 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) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyEnumType(result1585) + + case 17: + result1587 := 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)) + value1586 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1587 = append(result1587, value1586) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1587) + + case 18: + result1588 := 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) + + result1588 = append(result1588, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyTupleType(result1588) + + case 19: + + variant1650 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1650 = 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: + + variant1650 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1650 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1589 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1589 = witTypes.None[int32]() + case 1: + + option1589 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1590 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1590 = witTypes.None[int32]() + case 1: + + option1590 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1589, option1590}) + + case 24: + var option1593 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1593 = witTypes.None[[]string]() + case 1: + result1592 := 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)) + value1591 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1592 = append(result1592, value1591) + } + + option1593 = witTypes.Some[[]string](result1592) + default: + panic("unreachable") + } + var option1594 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1594 = witTypes.None[uint32]() + case 1: + + option1594 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1595 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1595 = witTypes.None[uint32]() + case 1: + + option1595 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1597 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1597 = witTypes.None[string]() + case 1: + value1596 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1597 = witTypes.Some[string](value1596) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1593, option1594, option1595, option1597}) + + case 25: + var option1600 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1600 = witTypes.None[[]string]() + case 1: + result1599 := 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)) + value1598 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1599 = append(result1599, value1598) + } + + option1600 = witTypes.Some[[]string](result1599) + default: + panic("unreachable") + } + var option1601 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1601 = witTypes.None[uint32]() + case 1: + + option1601 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1602 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1602 = witTypes.None[uint32]() + case 1: + + option1602 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1600, option1601, option1602}) + + case 26: + var option1605 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1605 = witTypes.None[[]string]() + case 1: + result1604 := 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)) + value1603 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1604 = append(result1604, value1603) + } + + option1605 = witTypes.Some[[]string](result1604) + default: + panic("unreachable") + } + var option1608 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1608 = witTypes.None[[]string]() + case 1: + result1607 := 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)) + value1606 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1607 = append(result1607, value1606) + } + + option1608 = witTypes.Some[[]string](result1607) + default: + panic("unreachable") + } + + variant1650 = 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)))), option1605, option1608}) + + case 27: + var option1611 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1611 = witTypes.None[[]string]() + case 1: + result1610 := 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)) + value1609 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1610 = append(result1610, value1609) + } + + option1611 = witTypes.Some[[]string](result1610) + default: + panic("unreachable") + } + var option1614 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1614 = witTypes.None[[]string]() + case 1: + result1613 := 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)) + value1612 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1613 = append(result1613, value1612) + } + + option1614 = witTypes.Some[[]string](result1613) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1611, option1614}) + + case 28: + + variant1650 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1650 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1615 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1617 := 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)) + value1616 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1617 = append(result1617, value1616) + } + + var option1619 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1619 = 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))), value1618}) + default: + panic("unreachable") + } + var option1621 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option1621 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value1620 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1621 = 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))), value1620}) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1615, result1617, option1619, option1621}) + + case 31: + result1643 := 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)) + value1622 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1631 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1623 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRulePrefix(value1623) + + case 1: + value1624 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleSuffix(value1624) + + case 2: + value1625 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleContains(value1625) + + case 3: + value1626 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleRegex(value1626) + + case 4: + value1627 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1629 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1629 = witTypes.None[string]() + case 1: + value1628 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1629 = witTypes.Some[string](value1628) + default: + panic("unreachable") + } + + variant1631 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1627, option1629}) + + case 5: + value1630 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1631 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1630) + + default: + panic("unreachable") + } + var option1633 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1633 = witTypes.None[string]() + case 1: + value1632 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1633 = witTypes.Some[string](value1632) + default: + panic("unreachable") + } + result1635 := 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)) + 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) + } + + result1637 := 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)) + value1636 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1637 = append(result1637, value1636) + } + + var option1639 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1639 = witTypes.None[string]() + case 1: + value1638 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1639 = witTypes.Some[string](value1638) + default: + panic("unreachable") + } + var option1642 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1642 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1641 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1641 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1641 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1641 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1640 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1641 = golem_core_types.MakeRoleOther(value1640) + + default: + panic("unreachable") + } + + option1642 = witTypes.Some[golem_core_types.Role](variant1641) + default: + panic("unreachable") + } + + result1643 = append(result1643, golem_core_types.UnionBranch{value1622, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1631, golem_core_types.MetadataEnvelope{option1633, result1635, result1637, option1639, option1642}}) + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1643}) + + case 32: + var option1645 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1645 = witTypes.None[string]() + case 1: + value1644 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1645 = witTypes.Some[string](value1644) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1645}) + + case 33: + var option1647 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1647 = witTypes.None[string]() + case 1: + value1646 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1647 = witTypes.Some[string](value1646) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1647}) + + case 34: + + variant1650 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1648 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1648 = witTypes.None[int32]() + case 1: + + option1648 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyFutureType(option1648) + + case 36: + var option1649 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1649 = witTypes.None[int32]() + case 1: + + option1649 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1650 = golem_core_types.MakeSchemaTypeBodyStreamType(option1649) + + default: + panic("unreachable") + } + var option1652 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1652 = witTypes.None[string]() + case 1: + value1651 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1652 = witTypes.Some[string](value1651) + default: + panic("unreachable") + } + result1654 := 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)) + 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) + } + + result1656 := 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)) + value1655 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1656 = append(result1656, value1655) + } + + var option1658 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1658 = witTypes.None[string]() + case 1: + value1657 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1658 = witTypes.Some[string](value1657) + default: + panic("unreachable") + } + var option1661 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1661 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1660 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1660 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1660 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1660 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1659 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1660 = golem_core_types.MakeRoleOther(value1659) + + default: + panic("unreachable") + } + + option1661 = witTypes.Some[golem_core_types.Role](variant1660) + default: + panic("unreachable") + } + + result1662 = append(result1662, golem_core_types.SchemaTypeNode{variant1650, golem_core_types.MetadataEnvelope{option1652, result1654, result1656, option1658, option1661}}) + } + + result1666 := 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)) + value1663 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1665 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1665 = witTypes.None[string]() + case 1: + value1664 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1665 = witTypes.Some[string](value1664) + default: + panic("unreachable") + } + + result1666 = append(result1666, golem_core_types.SchemaTypeDef{value1663, option1665, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1690 := 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 variant1689 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1689 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1689 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1689 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1689 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1689 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1689 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1689 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1689 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1689 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1689 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1689 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1689 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1667 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeStringValue(value1667) + + case 13: + result1668 := 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) + + result1668 = append(result1668, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeRecordValue(result1668) + + case 14: + var option1669 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1669 = witTypes.None[int32]() + case 1: + + option1669 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1669}) + + case 15: + + variant1689 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1670 := 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) + + result1670 = append(result1670, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1670) + + case 17: + 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))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeTupleValue(result1671) + + case 18: + result1672 := 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) + + result1672 = append(result1672, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeListValue(result1672) + + case 19: + result1673 := 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) + + result1673 = append(result1673, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1673) + + case 20: + result1674 := 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) + + result1674 = append(result1674, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1689 = golem_core_types.MakeSchemaValueNodeMapValue(result1674) + + case 21: + var option1675 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1675 = witTypes.None[int32]() + case 1: + + option1675 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeOptionValue(option1675) + + case 22: + var variant1678 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1676 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1676 = witTypes.None[int32]() + case 1: + + option1676 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1678 = golem_core_types.MakeResultValuePayloadOkValue(option1676) + + case 1: + var option1677 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1677 = witTypes.None[int32]() + case 1: + + option1677 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1678 = golem_core_types.MakeResultValuePayloadErrValue(option1677) + + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeResultValue(variant1678) + + case 23: + value1679 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1681 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1681 = witTypes.None[string]() + case 1: + value1680 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1681 = witTypes.Some[string](value1680) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1679, option1681}) + + case 24: + value1682 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1684 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1684 = witTypes.None[string]() + case 1: + value1683 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1684 = witTypes.Some[string](value1683) + default: + panic("unreachable") + } + + variant1689 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1682, option1684}) + + case 25: + value1685 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodePathValue(value1685) + + case 26: + value1686 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeUrlValue(value1686) + + case 27: + + variant1689 = 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: + + variant1689 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1687 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1687}) + + case 30: + value1688 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1689 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1688, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1689 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1689 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1689 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1690 = append(result1690, variant1689) + } + + variant1697 = MakeAgentInvocationResultAgentMethod(AgentInvocationOutputParameters{golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1662, result1666, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))}, golem_core_types.SchemaValueTree{result1690, *(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 8*4)))}}}) + + case 2: + + variant1697 = MakeAgentInvocationResultManualUpdate() + + case 3: + var option1692 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) { + case 0: + + option1692 = witTypes.None[string]() + case 1: + value1691 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + option1692 = witTypes.Some[string](value1691) + default: + panic("unreachable") + } + + variant1697 = MakeAgentInvocationResultLoadSnapshot(FallibleResultParameters{option1692}) + + case 4: + value1693 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) + value1694 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) + + variant1697 = MakeAgentInvocationResultSaveSnapshot(SaveSnapshotResultParameters{SnapshotData{value1693, value1694}}) + + case 5: + var option1696 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) { + case 0: + + option1696 = witTypes.None[string]() + case 1: + value1695 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + option1696 = witTypes.Some[string](value1695) + default: + panic("unreachable") + } + + variant1697 = MakeAgentInvocationResultProcessOplogEntries(FallibleResultParameters{option1696}) + + default: + panic("unreachable") + } + var option1699 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 9*4)))) { + case 0: + + option1699 = witTypes.None[string]() + case 1: + value1698 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 11*4)))) + + option1699 = witTypes.Some[string](value1698) + default: + panic("unreachable") + } + + variant2472 = 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)))}, variant1697, option1699, *(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))), uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4))))}) + + case 6: + + variant2472 = 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: + value1700 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + var option1703 witTypes.Option[RetryPolicyState] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))) { + case 0: + + option1703 = witTypes.None[RetryPolicyState]() + case 1: + result1702 := 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 variant1701 StateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1701 = MakeStateNodeCounter(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)))) + + case 1: + + variant1701 = MakeStateNodeTerminal() + + case 2: + + variant1701 = MakeStateNodeWrapper(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))) + + case 3: + + variant1701 = MakeStateNodeCountBox(CountBoxState{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 4))), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 4: + + variant1701 = 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: + + variant1701 = MakeStateNodePair(PairState{*(*int32)(unsafe.Add(unsafe.Pointer(base), 4)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 8))}) + + default: + panic("unreachable") + } + + result1702 = append(result1702, variant1701) + } + + option1703 = witTypes.Some[RetryPolicyState](RetryPolicyState{result1702}) + default: + panic("unreachable") + } + + variant2472 = 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)))}, value1700, uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) != 0), option1703}) + + case 8: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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: + + variant2472 = 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 variant2148 AgentInvocation + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + value1704 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + result1880 := 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 variant1868 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1868 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant1868 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1711 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1711 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1706 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1705 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1705 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1705 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1706 = witTypes.Some[golem_core_types.NumericBound](variant1705) + default: + panic("unreachable") + } + var option1708 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1707 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1707 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1707 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1708 = witTypes.Some[golem_core_types.NumericBound](variant1707) + default: + panic("unreachable") + } + var option1710 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1710 = witTypes.None[string]() + case 1: + value1709 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1710 = witTypes.Some[string](value1709) + default: + panic("unreachable") + } + + option1711 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1706, option1708, option1710}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS8Type(option1711) + + case 3: + var option1718 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1718 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1713 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1712 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1712 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1712 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1713 = witTypes.Some[golem_core_types.NumericBound](variant1712) + default: + panic("unreachable") + } + var option1715 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1714 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1714 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1714 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1715 = witTypes.Some[golem_core_types.NumericBound](variant1714) + default: + panic("unreachable") + } + var option1717 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1717 = witTypes.None[string]() + case 1: + value1716 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1717 = witTypes.Some[string](value1716) + default: + panic("unreachable") + } + + option1718 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1713, option1715, option1717}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS16Type(option1718) + + case 4: + var option1725 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1725 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1720 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1719 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1719 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1719 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1720 = witTypes.Some[golem_core_types.NumericBound](variant1719) + default: + panic("unreachable") + } + var option1722 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1721 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1721 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1721 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1722 = witTypes.Some[golem_core_types.NumericBound](variant1721) + default: + panic("unreachable") + } + var option1724 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1724 = witTypes.None[string]() + case 1: + value1723 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1724 = witTypes.Some[string](value1723) + default: + panic("unreachable") + } + + option1725 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1720, option1722, option1724}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS32Type(option1725) + + case 5: + var option1732 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1732 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1727 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1726 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1726 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1726 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1727 = witTypes.Some[golem_core_types.NumericBound](variant1726) + default: + panic("unreachable") + } + var option1729 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1728 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1728 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1728 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1729 = witTypes.Some[golem_core_types.NumericBound](variant1728) + default: + panic("unreachable") + } + var option1731 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1731 = witTypes.None[string]() + case 1: + value1730 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1731 = witTypes.Some[string](value1730) + default: + panic("unreachable") + } + + option1732 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1727, option1729, option1731}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyS64Type(option1732) + + case 6: + var option1739 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1739 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1734 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1733 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1733 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1733 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1734 = witTypes.Some[golem_core_types.NumericBound](variant1733) + default: + panic("unreachable") + } + var option1736 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1735 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1735 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1735 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1736 = witTypes.Some[golem_core_types.NumericBound](variant1735) + default: + panic("unreachable") + } + var option1738 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1738 = witTypes.None[string]() + case 1: + value1737 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1738 = witTypes.Some[string](value1737) + default: + panic("unreachable") + } + + option1739 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1734, option1736, option1738}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU8Type(option1739) + + case 7: + var option1746 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1746 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1741 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1740 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1740 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1740 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1741 = witTypes.Some[golem_core_types.NumericBound](variant1740) + default: + panic("unreachable") + } + var option1743 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1742 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1742 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1742 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1743 = witTypes.Some[golem_core_types.NumericBound](variant1742) + default: + panic("unreachable") + } + var option1745 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1745 = witTypes.None[string]() + case 1: + value1744 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1745 = witTypes.Some[string](value1744) + default: + panic("unreachable") + } + + option1746 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1741, option1743, option1745}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU16Type(option1746) + + case 8: + var option1753 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1753 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1748 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1747 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1747 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1747 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1748 = witTypes.Some[golem_core_types.NumericBound](variant1747) + default: + panic("unreachable") + } + var option1750 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1749 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1749 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1749 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1750 = witTypes.Some[golem_core_types.NumericBound](variant1749) + default: + panic("unreachable") + } + var option1752 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1752 = witTypes.None[string]() + case 1: + value1751 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1752 = witTypes.Some[string](value1751) + default: + panic("unreachable") + } + + option1753 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1748, option1750, option1752}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU32Type(option1753) + + case 9: + var option1760 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1760 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1755 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1754 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1754 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1754 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1755 = witTypes.Some[golem_core_types.NumericBound](variant1754) + default: + panic("unreachable") + } + var option1757 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1756 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1756 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1756 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1757 = witTypes.Some[golem_core_types.NumericBound](variant1756) + default: + panic("unreachable") + } + var option1759 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1759 = witTypes.None[string]() + case 1: + value1758 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1759 = witTypes.Some[string](value1758) + default: + panic("unreachable") + } + + option1760 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1755, option1757, option1759}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyU64Type(option1760) + + case 10: + var option1767 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1767 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1762 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1761 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1761 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1761 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1762 = witTypes.Some[golem_core_types.NumericBound](variant1761) + default: + panic("unreachable") + } + var option1764 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1763 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1763 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1763 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1764 = witTypes.Some[golem_core_types.NumericBound](variant1763) + default: + panic("unreachable") + } + var option1766 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1766 = witTypes.None[string]() + case 1: + value1765 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1766 = witTypes.Some[string](value1765) + default: + panic("unreachable") + } + + option1767 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1762, option1764, option1766}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyF32Type(option1767) + + case 11: + var option1774 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1774 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1769 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1768 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1768 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1768 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1769 = witTypes.Some[golem_core_types.NumericBound](variant1768) + default: + panic("unreachable") + } + var option1771 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant1770 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1770 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1770 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1771 = witTypes.Some[golem_core_types.NumericBound](variant1770) + default: + panic("unreachable") + } + var option1773 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1773 = witTypes.None[string]() + case 1: + value1772 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1773 = witTypes.Some[string](value1772) + default: + panic("unreachable") + } + + option1774 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1769, option1771, option1773}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyF64Type(option1774) + + case 12: + + variant1868 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant1868 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result1787 := 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)) + value1775 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1777 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1777 = witTypes.None[string]() + case 1: + value1776 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1777 = witTypes.Some[string](value1776) + default: + panic("unreachable") + } + result1779 := 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)) + 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) + } + + result1781 := 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)) + 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) + } + + var option1783 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option1783 = witTypes.None[string]() + case 1: + value1782 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option1783 = witTypes.Some[string](value1782) + default: + panic("unreachable") + } + var option1786 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option1786 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1785 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant1785 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1785 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1785 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1784 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant1785 = golem_core_types.MakeRoleOther(value1784) + + default: + panic("unreachable") + } + + option1786 = witTypes.Some[golem_core_types.Role](variant1785) + default: + panic("unreachable") + } + + result1787 = append(result1787, golem_core_types.NamedFieldType{value1775, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1777, result1779, result1781, option1783, option1786}}) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyRecordType(result1787) + + case 15: + result1801 := 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)) + value1788 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1789 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1789 = witTypes.None[int32]() + case 1: + + option1789 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option1791 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1791 = witTypes.None[string]() + case 1: + value1790 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1791 = witTypes.Some[string](value1790) + default: + panic("unreachable") + } + result1793 := 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)) + 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) + } + + result1795 := 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)) + 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) + } + + var option1797 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option1797 = witTypes.None[string]() + case 1: + value1796 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option1797 = witTypes.Some[string](value1796) + default: + panic("unreachable") + } + var option1800 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option1800 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1799 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant1799 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1799 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1799 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1798 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant1799 = golem_core_types.MakeRoleOther(value1798) + + default: + panic("unreachable") + } + + option1800 = witTypes.Some[golem_core_types.Role](variant1799) + default: + panic("unreachable") + } + + result1801 = append(result1801, golem_core_types.VariantCaseType{value1788, option1789, golem_core_types.MetadataEnvelope{option1791, result1793, result1795, option1797, option1800}}) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyVariantType(result1801) + + case 16: + 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) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyEnumType(result1803) + + case 17: + 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) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyFlagsType(result1805) + + case 18: + result1806 := 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) + + result1806 = append(result1806, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyTupleType(result1806) + + case 19: + + variant1868 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant1868 = 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: + + variant1868 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant1868 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option1807 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1807 = witTypes.None[int32]() + case 1: + + option1807 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option1808 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option1808 = witTypes.None[int32]() + case 1: + + option1808 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option1807, option1808}) + + case 24: + var option1811 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1811 = witTypes.None[[]string]() + case 1: + result1810 := 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)) + value1809 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1810 = append(result1810, value1809) + } + + option1811 = witTypes.Some[[]string](result1810) + default: + panic("unreachable") + } + var option1812 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1812 = witTypes.None[uint32]() + case 1: + + option1812 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1813 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1813 = witTypes.None[uint32]() + case 1: + + option1813 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option1815 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option1815 = witTypes.None[string]() + case 1: + value1814 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option1815 = witTypes.Some[string](value1814) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option1811, option1812, option1813, option1815}) + + case 25: + var option1818 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1818 = witTypes.None[[]string]() + case 1: + result1817 := 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)) + value1816 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1817 = append(result1817, value1816) + } + + option1818 = witTypes.Some[[]string](result1817) + default: + panic("unreachable") + } + var option1819 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1819 = witTypes.None[uint32]() + case 1: + + option1819 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option1820 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option1820 = witTypes.None[uint32]() + case 1: + + option1820 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option1818, option1819, option1820}) + + case 26: + var option1823 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1823 = witTypes.None[[]string]() + case 1: + result1822 := 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)) + value1821 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1822 = append(result1822, value1821) + } + + option1823 = witTypes.Some[[]string](result1822) + default: + panic("unreachable") + } + var option1826 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option1826 = witTypes.None[[]string]() + case 1: + result1825 := 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)) + value1824 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1825 = append(result1825, value1824) + } + + option1826 = witTypes.Some[[]string](result1825) + default: + panic("unreachable") + } + + variant1868 = 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)))), option1823, option1826}) + + case 27: + var option1829 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1829 = witTypes.None[[]string]() + case 1: + result1828 := 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)) + value1827 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1828 = append(result1828, value1827) + } + + option1829 = witTypes.Some[[]string](result1828) + default: + panic("unreachable") + } + var option1832 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option1832 = witTypes.None[[]string]() + case 1: + result1831 := 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)) + value1830 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1831 = append(result1831, value1830) + } + + option1832 = witTypes.Some[[]string](result1831) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option1829, option1832}) + + case 28: + + variant1868 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant1868 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value1833 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result1835 := 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)) + value1834 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1835 = append(result1835, value1834) + } + + var option1837 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option1837 = 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))), value1836}) + default: + panic("unreachable") + } + var option1839 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*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), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option1839 = 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))), value1838}) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value1833, result1835, option1837, option1839}) + + case 31: + result1861 := 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)) + value1840 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1849 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value1841 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRulePrefix(value1841) + + case 1: + value1842 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleSuffix(value1842) + + case 2: + value1843 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleContains(value1843) + + case 3: + value1844 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleRegex(value1844) + + case 4: + value1845 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option1847 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option1847 = witTypes.None[string]() + case 1: + value1846 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option1847 = witTypes.Some[string](value1846) + default: + panic("unreachable") + } + + variant1849 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value1845, option1847}) + + case 5: + value1848 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant1849 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value1848) + + default: + panic("unreachable") + } + var option1851 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option1851 = witTypes.None[string]() + case 1: + value1850 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option1851 = witTypes.Some[string](value1850) + default: + panic("unreachable") + } + result1853 := 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)) + 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) + } + + result1855 := 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)) + 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) + } + + var option1857 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option1857 = witTypes.None[string]() + case 1: + value1856 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option1857 = witTypes.Some[string](value1856) + default: + panic("unreachable") + } + var option1860 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option1860 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1859 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant1859 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1859 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1859 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1858 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant1859 = golem_core_types.MakeRoleOther(value1858) + + default: + panic("unreachable") + } + + option1860 = witTypes.Some[golem_core_types.Role](variant1859) + default: + panic("unreachable") + } + + result1861 = append(result1861, golem_core_types.UnionBranch{value1840, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant1849, golem_core_types.MetadataEnvelope{option1851, result1853, result1855, option1857, option1860}}) + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result1861}) + + case 32: + var option1863 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option1863 = witTypes.None[string]() + case 1: + value1862 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option1863 = witTypes.Some[string](value1862) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option1863}) + + case 33: + var option1865 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1865 = witTypes.None[string]() + case 1: + value1864 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option1865 = witTypes.Some[string](value1864) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option1865}) + + case 34: + + variant1868 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option1866 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1866 = witTypes.None[int32]() + case 1: + + option1866 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyFutureType(option1866) + + case 36: + var option1867 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1867 = witTypes.None[int32]() + case 1: + + option1867 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1868 = golem_core_types.MakeSchemaTypeBodyStreamType(option1867) + + default: + panic("unreachable") + } + var option1870 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option1870 = witTypes.None[string]() + case 1: + value1869 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option1870 = witTypes.Some[string](value1869) + default: + panic("unreachable") + } + result1872 := 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)) + 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) + } + + result1874 := 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)) + 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) + } + + var option1876 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option1876 = witTypes.None[string]() + case 1: + value1875 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option1876 = witTypes.Some[string](value1875) + default: + panic("unreachable") + } + var option1879 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option1879 = witTypes.None[golem_core_types.Role]() + case 1: + var variant1878 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant1878 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant1878 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant1878 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value1877 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant1878 = golem_core_types.MakeRoleOther(value1877) + + default: + panic("unreachable") + } + + option1879 = witTypes.Some[golem_core_types.Role](variant1878) + default: + panic("unreachable") + } + + result1880 = append(result1880, golem_core_types.SchemaTypeNode{variant1868, golem_core_types.MetadataEnvelope{option1870, result1872, result1874, option1876, option1879}}) + } + + result1884 := 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)) + value1881 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1883 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option1883 = witTypes.None[string]() + case 1: + value1882 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option1883 = witTypes.Some[string](value1882) + default: + panic("unreachable") + } + + result1884 = append(result1884, golem_core_types.SchemaTypeDef{value1881, option1883, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result1908 := 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 variant1907 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant1907 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant1907 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant1907 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant1907 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant1907 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant1907 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant1907 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant1907 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant1907 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant1907 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant1907 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant1907 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value1885 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeStringValue(value1885) + + case 13: + result1886 := 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) + + result1886 = append(result1886, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeRecordValue(result1886) + + case 14: + var option1887 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1887 = witTypes.None[int32]() + case 1: + + option1887 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option1887}) + + case 15: + + variant1907 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result1888 := 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) + + result1888 = append(result1888, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeFlagsValue(result1888) + + case 17: + 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))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeTupleValue(result1889) + + case 18: + result1890 := 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) + + result1890 = append(result1890, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeListValue(result1890) + + case 19: + 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))) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeFixedListValue(result1891) + + case 20: + result1892 := 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) + + result1892 = append(result1892, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant1907 = golem_core_types.MakeSchemaValueNodeMapValue(result1892) + + case 21: + var option1893 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1893 = witTypes.None[int32]() + case 1: + + option1893 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeOptionValue(option1893) + + case 22: + var variant1896 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option1894 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1894 = witTypes.None[int32]() + case 1: + + option1894 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1896 = golem_core_types.MakeResultValuePayloadOkValue(option1894) + + case 1: + var option1895 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option1895 = witTypes.None[int32]() + case 1: + + option1895 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant1896 = golem_core_types.MakeResultValuePayloadErrValue(option1895) + + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeResultValue(variant1896) + + case 23: + value1897 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1899 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1899 = witTypes.None[string]() + case 1: + value1898 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1899 = witTypes.Some[string](value1898) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value1897, option1899}) + + case 24: + value1900 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1902 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option1902 = witTypes.None[string]() + case 1: + value1901 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option1902 = witTypes.Some[string](value1901) + default: + panic("unreachable") + } + + variant1907 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value1900, option1902}) + + case 25: + value1903 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodePathValue(value1903) + + case 26: + value1904 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeUrlValue(value1904) + + case 27: + + variant1907 = 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: + + variant1907 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value1905 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value1905}) + + case 30: + value1906 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1907 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value1906, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant1907 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant1907 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant1907 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result1908 = append(result1908, variant1907) + } + + value1909 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4)))) + result1911 := 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)) + value1910 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result1911 = append(result1911, value1910) + } + + result1923 := 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)) + result1922 := 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 variant1921 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value1912 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option1914 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option1914 = witTypes.None[string]() + case 1: + value1913 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option1914 = witTypes.Some[string](value1913) + default: + panic("unreachable") + } + var option1915 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option1915 = witTypes.None[uint64]() + case 1: + + option1915 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result1919 := 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)) + value1916 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant1918 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value1917 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant1918 = golem_api_context.MakeAttributeValueString(value1917) + + default: + panic("unreachable") + } + + result1919 = append(result1919, golem_api_context.Attribute{value1916, variant1918}) + } + + variant1921 = MakeSpanDataLocalSpan(LocalSpanData{value1912, 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))))}, option1914, option1915, result1919, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value1920 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant1921 = MakeSpanDataExternalSpan(ExternalSpanData{value1920}) + + default: + panic("unreachable") + } + + result1922 = append(result1922, variant1921) + } + + result1923 = append(result1923, result1922) + } + + variant2148 = MakeAgentInvocationAgentInitialization(AgentInitializationParameters{value1704, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result1880, result1884, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 6*4)))}, golem_core_types.SchemaValueTree{result1908, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 9*4)))}}, value1909, result1911, result1923}) + + case 1: + value1924 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + value1925 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))) + result2101 := 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 variant2089 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2089 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant2089 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option1932 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1932 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1927 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1926 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1926 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1926 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1927 = witTypes.Some[golem_core_types.NumericBound](variant1926) + default: + panic("unreachable") + } + var option1929 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1929 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1928 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1928 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1928 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1928 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1929 = witTypes.Some[golem_core_types.NumericBound](variant1928) + default: + panic("unreachable") + } + var option1931 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1931 = witTypes.None[string]() + case 1: + value1930 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1931 = witTypes.Some[string](value1930) + default: + panic("unreachable") + } + + option1932 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1927, option1929, option1931}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS8Type(option1932) + + case 3: + var option1939 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1939 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1934 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1933 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1933 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1933 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1934 = witTypes.Some[golem_core_types.NumericBound](variant1933) + default: + panic("unreachable") + } + var option1936 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1936 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1935 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1935 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1935 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1935 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1936 = witTypes.Some[golem_core_types.NumericBound](variant1935) + default: + panic("unreachable") + } + var option1938 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1938 = witTypes.None[string]() + case 1: + value1937 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1938 = witTypes.Some[string](value1937) + default: + panic("unreachable") + } + + option1939 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1934, option1936, option1938}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS16Type(option1939) + + case 4: + var option1946 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1946 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1941 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1940 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1940 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1940 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1941 = witTypes.Some[golem_core_types.NumericBound](variant1940) + default: + panic("unreachable") + } + var option1943 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1943 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1942 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1942 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1942 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1942 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1943 = witTypes.Some[golem_core_types.NumericBound](variant1942) + default: + panic("unreachable") + } + var option1945 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1945 = witTypes.None[string]() + case 1: + value1944 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1945 = witTypes.Some[string](value1944) + default: + panic("unreachable") + } + + option1946 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1941, option1943, option1945}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS32Type(option1946) + + case 5: + var option1953 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1953 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1948 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1947 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1947 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1947 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1948 = witTypes.Some[golem_core_types.NumericBound](variant1947) + default: + panic("unreachable") + } + var option1950 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1950 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1949 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1949 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1949 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1949 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1950 = witTypes.Some[golem_core_types.NumericBound](variant1949) + default: + panic("unreachable") + } + var option1952 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1952 = witTypes.None[string]() + case 1: + value1951 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1952 = witTypes.Some[string](value1951) + default: + panic("unreachable") + } + + option1953 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1948, option1950, option1952}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyS64Type(option1953) + + case 6: + var option1960 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1960 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1955 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1954 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1954 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1954 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1955 = witTypes.Some[golem_core_types.NumericBound](variant1954) + default: + panic("unreachable") + } + var option1957 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1957 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1956 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1956 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1956 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1956 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1957 = witTypes.Some[golem_core_types.NumericBound](variant1956) + default: + panic("unreachable") + } + var option1959 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1959 = witTypes.None[string]() + case 1: + value1958 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1959 = witTypes.Some[string](value1958) + default: + panic("unreachable") + } + + option1960 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1955, option1957, option1959}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU8Type(option1960) + + case 7: + var option1967 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1967 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1962 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1961 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1961 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1961 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1962 = witTypes.Some[golem_core_types.NumericBound](variant1961) + default: + panic("unreachable") + } + var option1964 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1964 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1963 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1963 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1963 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1963 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1964 = witTypes.Some[golem_core_types.NumericBound](variant1963) + default: + panic("unreachable") + } + var option1966 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1966 = witTypes.None[string]() + case 1: + value1965 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1966 = witTypes.Some[string](value1965) + default: + panic("unreachable") + } + + option1967 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1962, option1964, option1966}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU16Type(option1967) + + case 8: + var option1974 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1974 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1969 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1968 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1968 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1968 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1969 = witTypes.Some[golem_core_types.NumericBound](variant1968) + default: + panic("unreachable") + } + var option1971 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1971 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1970 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1970 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1970 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1970 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1971 = witTypes.Some[golem_core_types.NumericBound](variant1970) + default: + panic("unreachable") + } + var option1973 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1973 = witTypes.None[string]() + case 1: + value1972 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1973 = witTypes.Some[string](value1972) + default: + panic("unreachable") + } + + option1974 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1969, option1971, option1973}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU32Type(option1974) + + case 9: + var option1981 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1981 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1976 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1975 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1975 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1975 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1976 = witTypes.Some[golem_core_types.NumericBound](variant1975) + default: + panic("unreachable") + } + var option1978 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1978 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1977 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1977 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1977 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1977 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1978 = witTypes.Some[golem_core_types.NumericBound](variant1977) + default: + panic("unreachable") + } + var option1980 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1980 = witTypes.None[string]() + case 1: + value1979 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1980 = witTypes.Some[string](value1979) + default: + panic("unreachable") + } + + option1981 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1976, option1978, option1980}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyU64Type(option1981) + + case 10: + var option1988 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1988 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1983 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1982 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1982 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1982 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1983 = witTypes.Some[golem_core_types.NumericBound](variant1982) + default: + panic("unreachable") + } + var option1985 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1985 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1984 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1984 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1984 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1984 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1985 = witTypes.Some[golem_core_types.NumericBound](variant1984) + default: + panic("unreachable") + } + var option1987 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1987 = witTypes.None[string]() + case 1: + value1986 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1987 = witTypes.Some[string](value1986) + default: + panic("unreachable") + } + + option1988 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1983, option1985, option1987}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyF32Type(option1988) + + case 11: + var option1995 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option1995 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option1990 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + 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), 24))) { + case 0: + + variant1989 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant1989 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant1989 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option1990 = witTypes.Some[golem_core_types.NumericBound](variant1989) + default: + panic("unreachable") + } + var option1992 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option1992 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant1991 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant1991 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant1991 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant1991 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option1992 = witTypes.Some[golem_core_types.NumericBound](variant1991) + default: + panic("unreachable") + } + var option1994 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option1994 = witTypes.None[string]() + case 1: + value1993 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option1994 = witTypes.Some[string](value1993) + default: + panic("unreachable") + } + + option1995 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option1990, option1992, option1994}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyF64Type(option1995) + + case 12: + + variant2089 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant2089 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result2008 := 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)) + value1996 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option1998 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option1998 = witTypes.None[string]() + case 1: + value1997 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option1998 = witTypes.Some[string](value1997) + default: + panic("unreachable") + } + result2000 := 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)) + 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) + } + + result2002 := 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)) + value2001 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2002 = append(result2002, value2001) + } + + var option2004 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option2004 = witTypes.None[string]() + case 1: + value2003 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option2004 = witTypes.Some[string](value2003) + default: + panic("unreachable") + } + var option2007 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option2007 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2006 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant2006 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2006 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2006 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2005 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant2006 = golem_core_types.MakeRoleOther(value2005) + + default: + panic("unreachable") + } + + option2007 = witTypes.Some[golem_core_types.Role](variant2006) + default: + panic("unreachable") + } + + result2008 = append(result2008, golem_core_types.NamedFieldType{value1996, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option1998, result2000, result2002, option2004, option2007}}) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyRecordType(result2008) + + case 15: + result2022 := 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)) + value2009 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2010 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2010 = witTypes.None[int32]() + case 1: + + option2010 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option2012 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2012 = witTypes.None[string]() + case 1: + value2011 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2012 = witTypes.Some[string](value2011) + default: + panic("unreachable") + } + result2014 := 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)) + 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) + } + + result2016 := 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)) + value2015 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2016 = append(result2016, value2015) + } + + var option2018 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option2018 = witTypes.None[string]() + case 1: + value2017 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option2018 = witTypes.Some[string](value2017) + default: + panic("unreachable") + } + var option2021 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option2021 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2020 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant2020 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2020 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2020 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2019 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant2020 = golem_core_types.MakeRoleOther(value2019) + + default: + panic("unreachable") + } + + option2021 = witTypes.Some[golem_core_types.Role](variant2020) + default: + panic("unreachable") + } + + result2022 = append(result2022, golem_core_types.VariantCaseType{value2009, option2010, golem_core_types.MetadataEnvelope{option2012, result2014, result2016, option2018, option2021}}) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyVariantType(result2022) + + case 16: + 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) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyEnumType(result2024) + + case 17: + result2026 := 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)) + value2025 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2026 = append(result2026, value2025) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2026) + + case 18: + result2027 := 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) + + result2027 = append(result2027, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyTupleType(result2027) + + case 19: + + variant2089 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant2089 = 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: + + variant2089 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant2089 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option2028 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2028 = witTypes.None[int32]() + case 1: + + option2028 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option2029 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2029 = witTypes.None[int32]() + case 1: + + option2029 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2028, option2029}) + + case 24: + var option2032 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2032 = witTypes.None[[]string]() + case 1: + result2031 := 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)) + value2030 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2031 = append(result2031, value2030) + } + + option2032 = witTypes.Some[[]string](result2031) + default: + panic("unreachable") + } + var option2033 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2033 = witTypes.None[uint32]() + case 1: + + option2033 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2034 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2034 = witTypes.None[uint32]() + case 1: + + option2034 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option2036 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option2036 = witTypes.None[string]() + case 1: + value2035 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option2036 = witTypes.Some[string](value2035) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2032, option2033, option2034, option2036}) + + case 25: + var option2039 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2039 = witTypes.None[[]string]() + case 1: + result2038 := 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)) + value2037 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2038 = append(result2038, value2037) + } + + option2039 = witTypes.Some[[]string](result2038) + default: + panic("unreachable") + } + var option2040 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2040 = witTypes.None[uint32]() + case 1: + + option2040 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2041 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2041 = witTypes.None[uint32]() + case 1: + + option2041 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2039, option2040, option2041}) + + case 26: + var option2044 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2044 = witTypes.None[[]string]() + case 1: + result2043 := 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)) + value2042 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2043 = append(result2043, value2042) + } + + option2044 = witTypes.Some[[]string](result2043) + default: + panic("unreachable") + } + var option2047 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2047 = witTypes.None[[]string]() + case 1: + result2046 := 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)) + value2045 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2046 = append(result2046, value2045) + } + + option2047 = witTypes.Some[[]string](result2046) + default: + panic("unreachable") + } + + variant2089 = 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)))), option2044, option2047}) + + case 27: + var option2050 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2050 = witTypes.None[[]string]() + case 1: + result2049 := 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)) + value2048 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2049 = append(result2049, value2048) + } + + option2050 = witTypes.Some[[]string](result2049) + default: + panic("unreachable") + } + var option2053 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2053 = witTypes.None[[]string]() + case 1: + result2052 := 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)) + value2051 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2052 = append(result2052, value2051) + } + + option2053 = witTypes.Some[[]string](result2052) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2050, option2053}) + + case 28: + + variant2089 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant2089 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value2054 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2056 := 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)) + value2055 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2056 = append(result2056, value2055) + } + + var option2058 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*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), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option2058 = 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))), value2057}) + default: + panic("unreachable") + } + var option2060 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option2060 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2059 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option2060 = 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))), value2059}) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2054, result2056, option2058, option2060}) + + case 31: + result2082 := 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)) + value2061 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2070 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value2062 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRulePrefix(value2062) + + case 1: + value2063 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleSuffix(value2063) + + case 2: + value2064 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleContains(value2064) + + case 3: + value2065 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleRegex(value2065) + + case 4: + value2066 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option2068 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option2068 = witTypes.None[string]() + case 1: + value2067 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option2068 = witTypes.Some[string](value2067) + default: + panic("unreachable") + } + + variant2070 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2066, option2068}) + + case 5: + value2069 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2070 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2069) + + default: + panic("unreachable") + } + var option2072 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option2072 = witTypes.None[string]() + case 1: + value2071 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option2072 = witTypes.Some[string](value2071) + default: + panic("unreachable") + } + result2074 := 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)) + 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) + } + + result2076 := 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)) + value2075 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2076 = append(result2076, value2075) + } + + var option2078 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option2078 = witTypes.None[string]() + case 1: + value2077 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option2078 = witTypes.Some[string](value2077) + default: + panic("unreachable") + } + var option2081 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option2081 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2080 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant2080 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2080 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2080 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2079 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant2080 = golem_core_types.MakeRoleOther(value2079) + + default: + panic("unreachable") + } + + option2081 = witTypes.Some[golem_core_types.Role](variant2080) + default: + panic("unreachable") + } + + result2082 = append(result2082, golem_core_types.UnionBranch{value2061, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2070, golem_core_types.MetadataEnvelope{option2072, result2074, result2076, option2078, option2081}}) + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2082}) + + case 32: + var option2084 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2084 = witTypes.None[string]() + case 1: + value2083 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option2084 = witTypes.Some[string](value2083) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2084}) + + case 33: + var option2086 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2086 = witTypes.None[string]() + case 1: + value2085 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option2086 = witTypes.Some[string](value2085) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2086}) + + case 34: + + variant2089 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyFutureType(option2087) + + case 36: + var option2088 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2088 = witTypes.None[int32]() + case 1: + + option2088 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2089 = golem_core_types.MakeSchemaTypeBodyStreamType(option2088) + + default: + panic("unreachable") + } + var option2091 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option2091 = witTypes.None[string]() + case 1: + value2090 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option2091 = witTypes.Some[string](value2090) + default: + panic("unreachable") + } + result2093 := 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)) + 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) + } + + result2095 := 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)) + value2094 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2095 = append(result2095, value2094) + } + + var option2097 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option2097 = witTypes.None[string]() + case 1: + value2096 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option2097 = witTypes.Some[string](value2096) + default: + panic("unreachable") + } + var option2100 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option2100 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2099 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant2099 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2099 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2099 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2098 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant2099 = golem_core_types.MakeRoleOther(value2098) + + default: + panic("unreachable") + } + + option2100 = witTypes.Some[golem_core_types.Role](variant2099) + default: + panic("unreachable") + } + + result2101 = append(result2101, golem_core_types.SchemaTypeNode{variant2089, golem_core_types.MetadataEnvelope{option2091, result2093, result2095, option2097, option2100}}) + } + + result2105 := 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)) + value2102 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2104 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2104 = witTypes.None[string]() + case 1: + value2103 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option2104 = witTypes.Some[string](value2103) + default: + panic("unreachable") + } + + result2105 = append(result2105, golem_core_types.SchemaTypeDef{value2102, option2104, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result2129 := 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 variant2128 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2128 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant2128 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant2128 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant2128 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant2128 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant2128 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant2128 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant2128 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant2128 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant2128 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant2128 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant2128 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value2106 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeStringValue(value2106) + + case 13: + result2107 := 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) + + result2107 = append(result2107, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeRecordValue(result2107) + + case 14: + var option2108 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2108 = witTypes.None[int32]() + case 1: + + option2108 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2108}) + + case 15: + + variant2128 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result2109 := 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) + + result2109 = append(result2109, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2109) + + case 17: + 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))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeTupleValue(result2110) + + case 18: + 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))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeListValue(result2111) + + case 19: + result2112 := 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) + + result2112 = append(result2112, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2112) + + case 20: + result2113 := 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) + + result2113 = append(result2113, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant2128 = golem_core_types.MakeSchemaValueNodeMapValue(result2113) + + case 21: + var option2114 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2114 = witTypes.None[int32]() + case 1: + + option2114 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeOptionValue(option2114) + + case 22: + var variant2117 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant2117 = golem_core_types.MakeResultValuePayloadOkValue(option2115) + + case 1: + var option2116 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2116 = witTypes.None[int32]() + case 1: + + option2116 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2117 = golem_core_types.MakeResultValuePayloadErrValue(option2116) + + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeResultValue(variant2117) + + case 23: + value2118 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2120 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2120 = witTypes.None[string]() + case 1: + value2119 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2120 = witTypes.Some[string](value2119) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2118, option2120}) + + case 24: + value2121 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2123 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2123 = witTypes.None[string]() + case 1: + value2122 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2123 = witTypes.Some[string](value2122) + default: + panic("unreachable") + } + + variant2128 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2121, option2123}) + + case 25: + value2124 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodePathValue(value2124) + + case 26: + value2125 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeUrlValue(value2125) + + case 27: + + variant2128 = 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: + + variant2128 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value2126 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2126}) + + case 30: + value2127 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2128 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2127, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant2128 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant2128 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant2128 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result2129 = append(result2129, variant2128) + } + + value2130 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 12*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 13*4)))) + result2132 := 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)) + value2131 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2132 = append(result2132, value2131) + } + + result2144 := 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)) + result2143 := 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 variant2142 SpanData + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2135 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 2*4)))) { + case 0: + + option2135 = witTypes.None[string]() + case 1: + value2134 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))) + + option2135 = witTypes.Some[string](value2134) + default: + panic("unreachable") + } + var option2136 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + + option2136 = witTypes.None[uint64]() + case 1: + + option2136 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4))))) + default: + panic("unreachable") + } + result2140 := 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)) + value2137 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2139 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value2138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant2139 = golem_api_context.MakeAttributeValueString(value2138) + + default: + panic("unreachable") + } + + result2140 = append(result2140, golem_api_context.Attribute{value2137, variant2139}) + } + + variant2142 = MakeSpanDataLocalSpan(LocalSpanData{value2133, 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))))}, option2135, option2136, result2140, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 6*4)))) != 0)}) + + case 1: + value2141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2142 = MakeSpanDataExternalSpan(ExternalSpanData{value2141}) + + default: + panic("unreachable") + } + + result2143 = append(result2143, variant2142) + } + + result2144 = append(result2144, result2143) + } + + variant2148 = MakeAgentInvocationAgentMethodInvocation(AgentMethodInvocationParameters{value1924, value1925, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result2101, result2105, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}, golem_core_types.SchemaValueTree{result2129, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 11*4)))}}, value2130, result2132, result2144}) + + case 2: + + variant2148 = MakeAgentInvocationSaveSnapshot() + + case 3: + value2145 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + value2146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))) + + variant2148 = MakeAgentInvocationLoadSnapshot(LoadSnapshotParameters{SnapshotData{value2145, value2146}}) + + case 4: + value2147 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + + variant2148 = MakeAgentInvocationProcessOplogEntries(ProcessOplogEntriesParameters{value2147}) + + case 5: + + variant2148 = MakeAgentInvocationManualUpdate(ManualUpdateParameters{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))}) + + default: + panic("unreachable") + } + + variant2472 = 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)))}, variant2148}) + + case 15: + var variant2151 UpdateDescription + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + variant2151 = MakeUpdateDescriptionAutoUpdate() + + case 1: + value2149 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + value2150 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 4*4)))) + + variant2151 = MakeUpdateDescriptionSnapshotBased(golem_api_host.Snapshot{value2149, value2150}) + + default: + panic("unreachable") + } + + variant2472 = 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))), variant2151}) + + case 16: + result2157 := 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)) + value2152 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + value2153 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 4*4)))) + result2156 := 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)) + value2154 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2155 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2156 = append(result2156, witTypes.Tuple2[string, string]{value2154, value2155}) + } + + result2157 = append(result2157, 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)), value2152, value2153, result2156}) + } + + variant2472 = 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))), result2157}) + + case 17: + var option2159 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2159 = witTypes.None[string]() + case 1: + value2158 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))) + + option2159 = witTypes.Some[string](value2158) + default: + panic("unreachable") + } + + variant2472 = 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))), option2159}) + + case 18: + + variant2472 = 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: + + variant2472 = 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: + 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)))) + + variant2472 = 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))), value2160, value2161}) + + case 21: + value2162 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 1*4)))) + value2163 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (40 + 3*4)))) + + variant2472 = 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))), value2162, value2163}) + + case 22: + value2164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) + value2165 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) + + variant2472 = 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)))), value2164, value2165}) + + case 23: + + variant2472 = 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: + value2166 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))) + value2167 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4)))) + result2170 := 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)) + value2168 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2169 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2170 = append(result2170, witTypes.Tuple2[string, string]{value2168, value2169}) + } + + variant2472 = 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)), value2166, value2167, result2170}}) + + case 25: + value2171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))) + value2172 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4)))) + result2175 := 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)) + value2173 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2174 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2175 = append(result2175, witTypes.Tuple2[string, string]{value2173, value2174}) + } + + variant2472 = 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)), value2171, value2172, result2175}}) + + case 26: + + variant2472 = 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: + value2176 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant2472 = 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)))}, value2176}) + + case 28: + value2177 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + var option2179 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))) { + case 0: + + option2179 = witTypes.None[string]() + case 1: + value2178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) + + option2179 = witTypes.Some[string](value2178) + default: + panic("unreachable") + } + var option2181 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))) { + case 0: + + option2181 = witTypes.None[string]() + case 1: + value2180 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 7*4)))) + + option2181 = witTypes.Some[string](value2180) + default: + panic("unreachable") + } + result2185 := 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)) + value2182 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2184 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + value2183 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + variant2184 = golem_api_context.MakeAttributeValueString(value2183) + + default: + panic("unreachable") + } + + result2185 = append(result2185, golem_api_context.Attribute{value2182, variant2184}) + } + + variant2472 = 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)))}, value2177, option2179, option2181, result2185}) + + case 29: + value2186 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant2472 = 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)))}, value2186}) + + case 30: + value2187 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value2188 := 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 variant2190 golem_api_context.AttributeValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 4*4)))) { + case 0: + value2189 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) + + variant2190 = golem_api_context.MakeAttributeValueString(value2189) + + default: + panic("unreachable") + } + + variant2472 = 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)))}, value2187, value2188, variant2190}) + + case 31: + value2191 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant2472 = 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)))}, value2191}) + + case 32: + + variant2472 = 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 33: + + variant2472 = 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 34: + + variant2472 = 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 35: + + variant2472 = 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 36: + value2192 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + value2193 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 3*4)))) + + variant2472 = 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{value2192, value2193}}) + + case 37: + value2194 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 2*4)))) + value2195 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 4*4)))) + result2198 := 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)) + value2196 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + value2197 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) + + result2198 = append(result2198, witTypes.Tuple2[string, string]{value2196, value2197}) + } + + value2199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 6*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (72 + 7*4)))) + + variant2472 = 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)), value2194, value2195, result2198}, 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))))}}, value2199}, 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 38: + value2200 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + result2231 := 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 variant2230 golem_api_retry.PredicateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2201 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2203 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2202 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2203 = golem_api_retry.MakePredicateValueText(value2202) + + case 1: + + variant2203 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2203 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2201, variant2203}) + + case 1: + value2204 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2206 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2205 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2206 = golem_api_retry.MakePredicateValueText(value2205) + + case 1: + + variant2206 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2206 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2204, variant2206}) + + case 2: + value2207 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2209 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2208 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2209 = golem_api_retry.MakePredicateValueText(value2208) + + case 1: + + variant2209 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2209 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2207, variant2209}) + + case 3: + value2210 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2212 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2211 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2212 = golem_api_retry.MakePredicateValueText(value2211) + + case 1: + + variant2212 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2212 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2210, variant2212}) + + case 4: + value2213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2215 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2214 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2215 = golem_api_retry.MakePredicateValueText(value2214) + + case 1: + + variant2215 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2215 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2213, variant2215}) + + case 5: + value2216 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2218 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2217 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2218 = golem_api_retry.MakePredicateValueText(value2217) + + case 1: + + variant2218 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2218 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2230 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2216, variant2218}) + + case 6: + value2219 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropExists(value2219) + + case 7: + value2220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2223 := 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 variant2222 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2221 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2222 = golem_api_retry.MakePredicateValueText(value2221) + + case 1: + + variant2222 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 2: + + variant2222 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + default: + panic("unreachable") + } + + result2223 = append(result2223, variant2222) + } + + variant2230 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2220, result2223}) + + case 8: + value2224 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2225 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2224, value2225}) + + case 9: + value2226 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2226, value2227}) + + case 10: + value2228 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2229 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2230 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2228, value2229}) + + case 11: + + variant2230 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2230 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2230 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 14: + + variant2230 = golem_api_retry.MakePredicateNodePredTrue() + + case 15: + + variant2230 = golem_api_retry.MakePredicateNodePredFalse() + + default: + panic("unreachable") + } + + result2231 = append(result2231, variant2230) + } + + result2264 := 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 variant2263 golem_api_retry.PolicyNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2263 = golem_api_retry.MakePolicyNodePeriodic(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 1: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = golem_api_retry.MakePolicyNodeImmediate() + + case 4: + + variant2263 = golem_api_retry.MakePolicyNodeNever() + + case 5: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = 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: + + variant2263 = golem_api_retry.MakePolicyNodeJitter(golem_api_retry.JitterConfig{*(*float64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16))}) + + case 10: + result2262 := 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 variant2261 golem_api_retry.PredicateNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2232 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2234 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2234 = golem_api_retry.MakePredicateValueText(value2233) + + case 1: + + variant2234 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2234 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropEq(golem_api_retry.PropertyComparison{value2232, variant2234}) + + case 1: + value2235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2237 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2236 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2237 = golem_api_retry.MakePredicateValueText(value2236) + + case 1: + + variant2237 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2237 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropNeq(golem_api_retry.PropertyComparison{value2235, variant2237}) + + case 2: + value2238 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2240 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2240 = golem_api_retry.MakePredicateValueText(value2239) + + case 1: + + variant2240 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2240 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropGt(golem_api_retry.PropertyComparison{value2238, variant2240}) + + case 3: + value2241 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2243 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2242 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2243 = golem_api_retry.MakePredicateValueText(value2242) + + case 1: + + variant2243 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2243 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropGte(golem_api_retry.PropertyComparison{value2241, variant2243}) + + case 4: + value2244 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2246 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2245 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2246 = golem_api_retry.MakePredicateValueText(value2245) + + case 1: + + variant2246 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2246 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropLt(golem_api_retry.PropertyComparison{value2244, variant2246}) + + case 5: + value2247 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var variant2249 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + value2248 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) + + variant2249 = golem_api_retry.MakePredicateValueText(value2248) + + case 1: + + variant2249 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + case 2: + + variant2249 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) != 0)) + + default: + panic("unreachable") + } + + variant2261 = golem_api_retry.MakePredicateNodePropLte(golem_api_retry.PropertyComparison{value2247, variant2249}) + + case 6: + value2250 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropExists(value2250) + + case 7: + value2251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2254 := 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 variant2253 golem_api_retry.PredicateValue + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + value2252 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2253 = golem_api_retry.MakePredicateValueText(value2252) + + case 1: + + variant2253 = golem_api_retry.MakePredicateValueInteger(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 2: + + variant2253 = golem_api_retry.MakePredicateValueBoolean((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + default: + panic("unreachable") + } + + result2254 = append(result2254, variant2253) + } + + variant2261 = golem_api_retry.MakePredicateNodePropIn(golem_api_retry.PropertySetCheck{value2251, result2254}) + + case 8: + value2255 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2256 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropMatches(golem_api_retry.PropertyPattern{value2255, value2256}) + + case 9: + value2257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2258 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropStartsWith(golem_api_retry.PropertyPattern{value2257, value2258}) + + case 10: + value2259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + value2260 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + variant2261 = golem_api_retry.MakePredicateNodePropContains(golem_api_retry.PropertyPattern{value2259, value2260}) + + case 11: + + variant2261 = golem_api_retry.MakePredicateNodePredAnd(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2261 = golem_api_retry.MakePredicateNodePredOr(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2261 = golem_api_retry.MakePredicateNodePredNot(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 14: + + variant2261 = golem_api_retry.MakePredicateNodePredTrue() + + case 15: + + variant2261 = golem_api_retry.MakePredicateNodePredFalse() + + default: + panic("unreachable") + } + + result2262 = append(result2262, variant2261) + } + + variant2263 = golem_api_retry.MakePolicyNodeFilteredOn(golem_api_retry.FilteredConfig{golem_api_retry.RetryPredicate{result2262}, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 11: + + variant2263 = golem_api_retry.MakePolicyNodeAndThen(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 12: + + variant2263 = golem_api_retry.MakePolicyNodePolicyUnion(witTypes.Tuple2[int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 13: + + variant2263 = 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") + } + + result2264 = append(result2264, variant2263) + } + + variant2472 = 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{value2200, uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (32 + 2*4)))), golem_api_retry.RetryPredicate{result2231}, golem_api_retry.RetryPolicy{result2264}}}) + + case 39: + value2265 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 1*4)))) + + variant2472 = 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)))}, value2265}) + + case 40: + var variant2266 QueuedCardEvent + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + variant2266 = 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: + + variant2266 = 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") + } + + variant2472 = 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)))}, variant2266}) + + case 41: + var option2267 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 32))) { + case 0: + + option2267 = witTypes.None[uint64]() + case 1: + + option2267 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 40)))) + default: + panic("unreachable") + } + + variant2472 = 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)))}, option2267, 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 42: + + variant2472 = 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 43: + + variant2472 = 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 44: + + variant2472 = 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 45: + result2443 := 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 variant2431 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2431 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant2431 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option2274 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2274 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2269 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2269 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2268 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2268 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2268 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2268 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2269 = witTypes.Some[golem_core_types.NumericBound](variant2268) + default: + panic("unreachable") + } + var option2271 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2271 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2270 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2270 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2270 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2270 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2271 = witTypes.Some[golem_core_types.NumericBound](variant2270) + default: + panic("unreachable") + } + var option2273 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2273 = witTypes.None[string]() + case 1: + value2272 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2273 = witTypes.Some[string](value2272) + default: + panic("unreachable") + } + + option2274 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2269, option2271, option2273}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS8Type(option2274) + + case 3: + var option2281 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2281 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2276 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2276 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2275 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2275 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2275 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2275 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2276 = witTypes.Some[golem_core_types.NumericBound](variant2275) + default: + panic("unreachable") + } + var option2278 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2278 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2277 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2277 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2277 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2277 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2278 = witTypes.Some[golem_core_types.NumericBound](variant2277) + default: + panic("unreachable") + } + var option2280 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2280 = witTypes.None[string]() + case 1: + value2279 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2280 = witTypes.Some[string](value2279) + default: + panic("unreachable") + } + + option2281 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2276, option2278, option2280}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS16Type(option2281) + + case 4: + var option2288 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2288 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2283 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2283 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2282 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2282 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2282 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2282 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2283 = witTypes.Some[golem_core_types.NumericBound](variant2282) + default: + panic("unreachable") + } + var option2285 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2285 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2284 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2284 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2284 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2284 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2285 = witTypes.Some[golem_core_types.NumericBound](variant2284) + default: + panic("unreachable") + } + var option2287 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2287 = witTypes.None[string]() + case 1: + value2286 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2287 = witTypes.Some[string](value2286) + default: + panic("unreachable") + } + + option2288 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2283, option2285, option2287}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS32Type(option2288) + + case 5: + var option2295 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2295 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2290 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2290 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2289 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2289 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2289 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2289 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2290 = witTypes.Some[golem_core_types.NumericBound](variant2289) + default: + panic("unreachable") + } + var option2292 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2292 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2291 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2291 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2291 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2291 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2292 = witTypes.Some[golem_core_types.NumericBound](variant2291) + default: + panic("unreachable") + } + var option2294 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2294 = witTypes.None[string]() + case 1: + value2293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2294 = witTypes.Some[string](value2293) + default: + panic("unreachable") + } + + option2295 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2290, option2292, option2294}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyS64Type(option2295) + + case 6: + var option2302 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2302 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2297 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2297 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2296 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2296 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2296 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2296 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2297 = witTypes.Some[golem_core_types.NumericBound](variant2296) + default: + panic("unreachable") + } + var option2299 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2299 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2298 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2298 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2298 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2298 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2299 = witTypes.Some[golem_core_types.NumericBound](variant2298) + default: + panic("unreachable") + } + var option2301 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2301 = witTypes.None[string]() + case 1: + value2300 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2301 = witTypes.Some[string](value2300) + default: + panic("unreachable") + } + + option2302 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2297, option2299, option2301}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU8Type(option2302) + + case 7: + var option2309 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2309 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2304 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2304 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2303 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2303 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2303 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2303 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2304 = witTypes.Some[golem_core_types.NumericBound](variant2303) + default: + panic("unreachable") + } + var option2306 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2306 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2305 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2305 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2305 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2305 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2306 = witTypes.Some[golem_core_types.NumericBound](variant2305) + default: + panic("unreachable") + } + var option2308 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2308 = witTypes.None[string]() + case 1: + value2307 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2308 = witTypes.Some[string](value2307) + default: + panic("unreachable") + } + + option2309 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2304, option2306, option2308}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU16Type(option2309) + + case 8: + var option2316 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2316 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2311 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2311 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2310 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2310 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2310 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2310 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2311 = witTypes.Some[golem_core_types.NumericBound](variant2310) + default: + panic("unreachable") + } + var option2313 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2313 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2312 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2312 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2312 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2312 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2313 = witTypes.Some[golem_core_types.NumericBound](variant2312) + default: + panic("unreachable") + } + var option2315 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2315 = witTypes.None[string]() + case 1: + value2314 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2315 = witTypes.Some[string](value2314) + default: + panic("unreachable") + } + + option2316 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2311, option2313, option2315}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU32Type(option2316) + + case 9: + var option2323 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2323 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2318 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2318 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2317 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2317 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2317 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2317 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2318 = witTypes.Some[golem_core_types.NumericBound](variant2317) + default: + panic("unreachable") + } + var option2320 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2320 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2319 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2319 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2319 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2319 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2320 = witTypes.Some[golem_core_types.NumericBound](variant2319) + default: + panic("unreachable") + } + var option2322 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2322 = witTypes.None[string]() + case 1: + value2321 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2322 = witTypes.Some[string](value2321) + default: + panic("unreachable") + } + + option2323 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2318, option2320, option2322}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyU64Type(option2323) + + case 10: + var option2330 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2330 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2325 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2325 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2324 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2324 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2324 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2324 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2325 = witTypes.Some[golem_core_types.NumericBound](variant2324) + default: + panic("unreachable") + } + var option2327 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2327 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2326 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2326 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2326 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2326 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2327 = witTypes.Some[golem_core_types.NumericBound](variant2326) + default: + panic("unreachable") + } + var option2329 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2329 = witTypes.None[string]() + case 1: + value2328 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2329 = witTypes.Some[string](value2328) + default: + panic("unreachable") + } + + option2330 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2325, option2327, option2329}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyF32Type(option2330) + + case 11: + var option2337 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2337 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option2332 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2332 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2331 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant2331 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant2331 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant2331 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option2332 = witTypes.Some[golem_core_types.NumericBound](variant2331) + default: + panic("unreachable") + } + var option2334 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option2334 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant2333 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant2333 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant2333 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant2333 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option2334 = witTypes.Some[golem_core_types.NumericBound](variant2333) + default: + panic("unreachable") + } + var option2336 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option2336 = witTypes.None[string]() + case 1: + value2335 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option2336 = witTypes.Some[string](value2335) + default: + panic("unreachable") + } + + option2337 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option2332, option2334, option2336}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyF64Type(option2337) + + case 12: + + variant2431 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant2431 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result2350 := 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)) + value2338 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2340 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option2340 = witTypes.None[string]() + case 1: + value2339 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option2340 = witTypes.Some[string](value2339) + default: + panic("unreachable") + } + result2342 := 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)) + value2341 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2342 = append(result2342, value2341) + } + + result2344 := 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)) + value2343 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2344 = append(result2344, value2343) + } + + var option2346 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option2346 = witTypes.None[string]() + case 1: + value2345 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option2346 = witTypes.Some[string](value2345) + default: + panic("unreachable") + } + var option2349 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option2349 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2348 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant2348 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2348 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2348 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2347 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant2348 = golem_core_types.MakeRoleOther(value2347) + + default: + panic("unreachable") + } + + option2349 = witTypes.Some[golem_core_types.Role](variant2348) + default: + panic("unreachable") + } + + result2350 = append(result2350, golem_core_types.NamedFieldType{value2338, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option2340, result2342, result2344, option2346, option2349}}) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyRecordType(result2350) + + case 15: + result2364 := 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)) + value2351 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2352 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2352 = witTypes.None[int32]() + case 1: + + option2352 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option2354 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2354 = witTypes.None[string]() + case 1: + value2353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2354 = witTypes.Some[string](value2353) + default: + panic("unreachable") + } + result2356 := 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)) + value2355 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2356 = append(result2356, value2355) + } + + result2358 := 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)) + value2357 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2358 = append(result2358, value2357) + } + + var option2360 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option2360 = witTypes.None[string]() + case 1: + value2359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option2360 = witTypes.Some[string](value2359) + default: + panic("unreachable") + } + var option2363 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option2363 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2362 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant2362 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2362 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2362 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant2362 = golem_core_types.MakeRoleOther(value2361) + + default: + panic("unreachable") + } + + option2363 = witTypes.Some[golem_core_types.Role](variant2362) + default: + panic("unreachable") + } + + result2364 = append(result2364, golem_core_types.VariantCaseType{value2351, option2352, golem_core_types.MetadataEnvelope{option2354, result2356, result2358, option2360, option2363}}) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyVariantType(result2364) + + case 16: + result2366 := 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)) + value2365 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2366 = append(result2366, value2365) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyEnumType(result2366) + + case 17: + result2368 := 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)) + value2367 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2368 = append(result2368, value2367) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyFlagsType(result2368) + + case 18: + result2369 := 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) + + result2369 = append(result2369, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyTupleType(result2369) + + case 19: + + variant2431 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant2431 = 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: + + variant2431 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant2431 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option2370 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2370 = witTypes.None[int32]() + case 1: + + option2370 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option2371 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option2371 = witTypes.None[int32]() + case 1: + + option2371 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option2370, option2371}) + + case 24: + var option2374 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2374 = witTypes.None[[]string]() + case 1: + result2373 := 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)) + value2372 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2373 = append(result2373, value2372) + } + + option2374 = witTypes.Some[[]string](result2373) + default: + panic("unreachable") + } + var option2375 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2375 = witTypes.None[uint32]() + case 1: + + option2375 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2376 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2376 = witTypes.None[uint32]() + case 1: + + option2376 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option2378 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option2378 = witTypes.None[string]() + case 1: + value2377 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option2378 = witTypes.Some[string](value2377) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option2374, option2375, option2376, option2378}) + + case 25: + var option2381 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2381 = witTypes.None[[]string]() + case 1: + result2380 := 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)) + value2379 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2380 = append(result2380, value2379) + } + + option2381 = witTypes.Some[[]string](result2380) + default: + panic("unreachable") + } + var option2382 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2382 = witTypes.None[uint32]() + case 1: + + option2382 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option2383 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option2383 = witTypes.None[uint32]() + case 1: + + option2383 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option2381, option2382, option2383}) + + case 26: + var option2386 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2386 = witTypes.None[[]string]() + case 1: + result2385 := 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)) + value2384 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2385 = append(result2385, value2384) + } + + option2386 = witTypes.Some[[]string](result2385) + default: + panic("unreachable") + } + var option2389 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2389 = witTypes.None[[]string]() + case 1: + result2388 := 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)) + value2387 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2388 = append(result2388, value2387) + } + + option2389 = witTypes.Some[[]string](result2388) + default: + panic("unreachable") + } + + variant2431 = 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)))), option2386, option2389}) + + case 27: + var option2392 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2392 = witTypes.None[[]string]() + case 1: + result2391 := 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)) + value2390 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2391 = append(result2391, value2390) + } + + option2392 = witTypes.Some[[]string](result2391) + default: + panic("unreachable") + } + var option2395 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option2395 = witTypes.None[[]string]() + case 1: + result2394 := 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)) + value2393 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2394 = append(result2394, value2393) + } + + option2395 = witTypes.Some[[]string](result2394) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option2392, option2395}) + + case 28: + + variant2431 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant2431 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value2396 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result2398 := 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)) + value2397 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2398 = append(result2398, value2397) + } + + var option2400 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option2400 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2399 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option2400 = 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))), value2399}) + default: + panic("unreachable") + } + var option2402 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option2402 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value2401 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option2402 = 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))), value2401}) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value2396, result2398, option2400, option2402}) + + case 31: + result2424 := 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)) + value2403 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant2412 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value2404 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRulePrefix(value2404) + + case 1: + value2405 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleSuffix(value2405) + + case 2: + value2406 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleContains(value2406) + + case 3: + value2407 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleRegex(value2407) + + case 4: + value2408 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option2410 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option2410 = witTypes.None[string]() + case 1: + value2409 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option2410 = witTypes.Some[string](value2409) + default: + panic("unreachable") + } + + variant2412 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value2408, option2410}) + + case 5: + value2411 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant2412 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value2411) + + default: + panic("unreachable") + } + var option2414 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option2414 = witTypes.None[string]() + case 1: + value2413 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option2414 = witTypes.Some[string](value2413) + default: + panic("unreachable") + } + result2416 := 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)) + value2415 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2416 = append(result2416, value2415) + } + + result2418 := 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)) + value2417 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2418 = append(result2418, value2417) + } + + var option2420 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option2420 = witTypes.None[string]() + case 1: + value2419 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option2420 = witTypes.Some[string](value2419) + default: + panic("unreachable") + } + var option2423 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option2423 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2422 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant2422 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2422 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2422 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2421 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant2422 = golem_core_types.MakeRoleOther(value2421) + + default: + panic("unreachable") + } + + option2423 = witTypes.Some[golem_core_types.Role](variant2422) + default: + panic("unreachable") + } + + result2424 = append(result2424, golem_core_types.UnionBranch{value2403, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant2412, golem_core_types.MetadataEnvelope{option2414, result2416, result2418, option2420, option2423}}) + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result2424}) + + case 32: + var option2426 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option2426 = witTypes.None[string]() + case 1: + value2425 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option2426 = witTypes.Some[string](value2425) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option2426}) + + case 33: + var option2428 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2428 = witTypes.None[string]() + case 1: + value2427 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option2428 = witTypes.Some[string](value2427) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option2428}) + + case 34: + + variant2431 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + 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") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyFutureType(option2429) + + case 36: + var option2430 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2430 = witTypes.None[int32]() + case 1: + + option2430 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2431 = golem_core_types.MakeSchemaTypeBodyStreamType(option2430) + + default: + panic("unreachable") + } + var option2433 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option2433 = witTypes.None[string]() + case 1: + value2432 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option2433 = witTypes.Some[string](value2432) + default: + panic("unreachable") + } + result2435 := 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)) + value2434 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2435 = append(result2435, value2434) + } + + result2437 := 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)) + value2436 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result2437 = append(result2437, value2436) + } + + var option2439 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option2439 = witTypes.None[string]() + case 1: + value2438 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option2439 = witTypes.Some[string](value2438) + default: + panic("unreachable") + } + var option2442 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option2442 = witTypes.None[golem_core_types.Role]() + case 1: + var variant2441 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant2441 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant2441 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant2441 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value2440 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant2441 = golem_core_types.MakeRoleOther(value2440) + + default: + panic("unreachable") + } + + option2442 = witTypes.Some[golem_core_types.Role](variant2441) + default: + panic("unreachable") + } + + result2443 = append(result2443, golem_core_types.SchemaTypeNode{variant2431, golem_core_types.MetadataEnvelope{option2433, result2435, result2437, option2439, option2442}}) + } + + result2447 := 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)) + value2444 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option2446 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option2446 = witTypes.None[string]() + case 1: + value2445 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option2446 = witTypes.Some[string](value2445) + default: + panic("unreachable") + } + + result2447 = append(result2447, golem_core_types.SchemaTypeDef{value2444, option2446, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result2471 := 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 variant2470 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant2470 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant2470 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant2470 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant2470 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant2470 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant2470 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant2470 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant2470 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant2470 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant2470 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant2470 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant2470 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value2448 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeStringValue(value2448) + + case 13: + result2449 := 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) + + result2449 = append(result2449, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeRecordValue(result2449) + + case 14: + var option2450 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2450 = witTypes.None[int32]() + case 1: + + option2450 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option2450}) + + case 15: + + variant2470 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result2451 := 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) + + result2451 = append(result2451, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeFlagsValue(result2451) + + case 17: + 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))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeTupleValue(result2452) + + case 18: + 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))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeListValue(result2453) + + case 19: + result2454 := 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) + + result2454 = append(result2454, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeFixedListValue(result2454) + + case 20: + result2455 := 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) + + result2455 = append(result2455, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant2470 = golem_core_types.MakeSchemaValueNodeMapValue(result2455) + + case 21: + var option2456 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option2456 = witTypes.None[int32]() + case 1: + + option2456 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeOptionValue(option2456) + + case 22: + var variant2459 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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") + } + + variant2459 = golem_core_types.MakeResultValuePayloadOkValue(option2457) + + case 1: + var option2458 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option2458 = witTypes.None[int32]() + case 1: + + option2458 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant2459 = golem_core_types.MakeResultValuePayloadErrValue(option2458) + + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeResultValue(variant2459) + + case 23: + value2460 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2462 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2462 = witTypes.None[string]() + case 1: + value2461 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2462 = witTypes.Some[string](value2461) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value2460, option2462}) + + case 24: + value2463 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option2465 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option2465 = witTypes.None[string]() + case 1: + value2464 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option2465 = witTypes.Some[string](value2464) + default: + panic("unreachable") + } + + variant2470 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value2463, option2465}) + + case 25: + value2466 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodePathValue(value2466) + + case 26: + value2467 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeUrlValue(value2467) + + case 27: + + variant2470 = 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: + + variant2470 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value2468 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value2468}) + + case 30: + value2469 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant2470 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value2469, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant2470 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant2470 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant2470 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result2471 = append(result2471, variant2470) + } + + variant2472 = 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{result2443, result2447, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 5*4)))}, golem_core_types.SchemaValueTree{result2471, *(*int32)(unsafe.Add(unsafe.Pointer(base), (40 + 8*4)))}}}) + + case 46: + + variant2472 = 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)))}) + + case 47: + + variant2472 = MakePublicOplogEntryCompletionDelivered(CompletionDeliveredParameters{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") + } + + result2473 = append(result2473, witTypes.Tuple2[uint64, PublicOplogEntry]{uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 0))), variant2472}) + } + + option2474 = witTypes.Some[[]witTypes.Tuple2[uint64, PublicOplogEntry]](result2473) + default: + panic("unreachable") + } + + result2477 = witTypes.Ok[witTypes.Option[[]witTypes.Tuple2[uint64, PublicOplogEntry]], OplogReadError](option2474) + case 1: + var variant2476 OplogReadError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + + variant2476 = MakeOplogReadErrorPermissionDenied() + + case 1: + value2475 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant2476 = MakeOplogReadErrorInternalError(value2475) + + default: + panic("unreachable") + } + + result2477 = witTypes.Err[witTypes.Option[[]witTypes.Tuple2[uint64, PublicOplogEntry]], OplogReadError](variant2476) + default: + panic("unreachable") + } + result2478 := result2477 + return result2478 + +} 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..80d4022136 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_api_retry/wit_bindings.go @@ -0,0 +1,2730 @@ +// 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.6.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:permissions@0.1.0 +// 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..e18b11e0ed --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_api_save_snapshot/wit_bindings.go @@ -0,0 +1,39 @@ +// 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.6.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:permissions@0.1.0 +// 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..c02496b268 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_core_types/wit_bindings.go @@ -0,0 +1,1581 @@ +// 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.6.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:permissions@0.1.0 +// 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} +} + +//go:wasmimport golem:core/types@2.0.0 [resource-drop]permission-card +func resourceDropPermissionCard(handle int32) + +// An unforgeable handle to a permission card held by the runtime. The +// handle is opaque to guests: components can hold, pass, derive, install, +// and revoke cards only through the `golem:permissions` interfaces. When +// carried in a `schema-value-tree` (see +// `schema-value-node::permission-card-handle`) the handle is transferred +// by ownership; the host converts it to/from its internal trusted +// card-store representation at the boundary. The wire form is the card-id +// (UUID) alone — no grants, parents, or metadata cross the wire as +// authority. +type PermissionCard struct { + handle *witRuntime.Handle +} + +func (self *PermissionCard) TakeHandle() int32 { + return self.handle.Take() +} + +func (self *PermissionCard) SetHandle(handle int32) { + self.handle.Set(handle) +} + +func (self *PermissionCard) Handle() int32 { + return self.handle.Use() +} + +func (self *PermissionCard) Drop() { + handle := self.handle.TakeOrNil() + if handle != 0 { + resourceDropPermissionCard(handle) + } +} + +func PermissionCardFromOwnHandle(handleValue int32) *PermissionCard { + handle := witRuntime.MakeHandle(handleValue) + value := &PermissionCard{handle} + runtime.AddCleanup(value, func(_ int) { + handleValue := handle.TakeOrNil() + if handleValue != 0 { + resourceDropPermissionCard(handleValue) + } + }, 0) + return value +} + +func PermissionCardFromBorrowHandle(handleValue int32) *PermissionCard { + handle := witRuntime.MakeHandle(handleValue) + return &PermissionCard{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>` 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 has a match for this regex in the implementation's + // regex dialect. The pattern must include anchors when whole-string + // matching is required. + 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. +// +// Portable schema-construction contract: +// - branch `tag`s are unique within the union, +// - string-pattern discriminators (`prefix` / `suffix` / `contains` / +// `regex`) require a branch body whose canonical raw JSON +// representation is a string (`string-type`, `url-type`, `path-type`, +// or a `ref` resolving to one), +// - `field-equals` requires a record-shaped branch body that declares +// the referenced field; a literal additionally requires that field to +// have a canonical raw JSON string representation, +// - `field-absent` requires a record-shaped branch body that does not +// declare the referenced field, +// - byte-identical regex text is rejected first as duplicate syntax, +// without making a semantic claim about the regex language, +// - every remaining pair of discriminator rules is classified as +// overlapping, disjoint, or indeterminate. Overlapping pairs are rejected; +// disjoint and indeterminate pairs are accepted. Runtime decoders +// still reject a raw value that matches multiple accepted branches. +// +// The canonical pair classification is symmetric and based only on the +// raw discriminator rules; branch body schemas do not refine it: +// - two prefixes overlap exactly when either prefixes the other, +// - two suffixes overlap exactly when either suffixes the other, +// - every prefix/suffix, prefix/contains, suffix/contains, and +// contains/contains pair overlaps, +// - a string-pattern rule and a record-shaped rule are disjoint because +// a raw JSON value cannot be both a string and an object, +// - field-equals rules on different fields overlap; on the same field +// they are disjoint only when both literals are present and differ, +// - every pair of field-absent rules overlaps, +// - field-equals and field-absent are disjoint on the same field and +// overlap on different fields, +// - after the duplicate-syntax check above, every pair containing a +// regex and another string-pattern rule is indeterminate and accepted. +// No portable semantic regex-overlap analysis is attempted because SDK +// regex dialects differ. +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] +} + +type PermissionCardSpec struct { + // `true` = polymorphic (carries slot variables in owner / resource-id), + // `false` = monomorphic. Structural metadata only; authority lives in + // the card store, not in the schema spec. + Polymorphic bool +} + +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 + SchemaTypeBodyPermissionCardType uint8 = 34 + // --- WASI P3 stubs (parseable only; no semantics yet) --- + SchemaTypeBodyFutureType uint8 = 35 + SchemaTypeBodyStreamType uint8 = 36 +) + +// 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) PermissionCardType() PermissionCardSpec { + if self.tag != SchemaTypeBodyPermissionCardType { + panic("tag mismatch") + } + return self.value.(PermissionCardSpec) +} +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 MakeSchemaTypeBodyPermissionCardType(value PermissionCardSpec) SchemaTypeBody { + return SchemaTypeBody{SchemaTypeBodyPermissionCardType, 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 + SchemaValueNodePermissionCardHandle uint8 = 33 +) + +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 (self SchemaValueNode) PermissionCardHandle() *PermissionCard { + if self.tag != SchemaValueNodePermissionCardHandle { + panic("tag mismatch") + } + return self.value.(*PermissionCard) +} + +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} +} +func MakeSchemaValueNodePermissionCardHandle(value *PermissionCard) SchemaValueNode { + return SchemaValueNode{SchemaValueNodePermissionCardHandle, 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..187073c0a6 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_durability_durability/wit_bindings.go @@ -0,0 +1,7080 @@ +// 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.6.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:permissions@0.1.0 +// 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_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 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 + +//go:wasmimport golem:durability/durability@1.6.0 [resource-drop]live-custom-durable-invocation +func resourceDropLiveCustomDurableInvocation(handle int32) + +// A live custom durable invocation. +// +// Host effects initiated while this resource is active are recorded as replay-inert +// observational entries belonging to the invocation. Finishing consumes the resource and +// persists the response. Dropping it without finishing leaves the invocation incomplete so +// normal recovery re-executes it. +type LiveCustomDurableInvocation struct { + handle *witRuntime.Handle +} + +func (self *LiveCustomDurableInvocation) TakeHandle() int32 { + return self.handle.Take() +} + +func (self *LiveCustomDurableInvocation) SetHandle(handle int32) { + self.handle.Set(handle) +} + +func (self *LiveCustomDurableInvocation) Handle() int32 { + return self.handle.Use() +} + +func (self *LiveCustomDurableInvocation) Drop() { + handle := self.handle.TakeOrNil() + if handle != 0 { + resourceDropLiveCustomDurableInvocation(handle) + } +} + +func LiveCustomDurableInvocationFromOwnHandle(handleValue int32) *LiveCustomDurableInvocation { + handle := witRuntime.MakeHandle(handleValue) + value := &LiveCustomDurableInvocation{handle} + runtime.AddCleanup(value, func(_ int) { + handleValue := handle.TakeOrNil() + if handleValue != 0 { + resourceDropLiveCustomDurableInvocation(handleValue) + } + }, 0) + return value +} + +func LiveCustomDurableInvocationFromBorrowHandle(handleValue int32) *LiveCustomDurableInvocation { + handle := witRuntime.MakeHandle(handleValue) + return &LiveCustomDurableInvocation{handle} +} + +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 +} + +const ( + // Execute the operation body and finish the returned live invocation. + CustomDurableInvocationLive uint8 = 0 + // Return the recorded response without executing the operation body. + CustomDurableInvocationReplayed uint8 = 1 +) + +// The result of opening a custom durable invocation. +type CustomDurableInvocation struct { + tag uint8 + value any +} + +func (self CustomDurableInvocation) Tag() uint8 { + return self.tag +} + +func (self CustomDurableInvocation) Live() *LiveCustomDurableInvocation { + if self.tag != CustomDurableInvocationLive { + panic("tag mismatch") + } + return self.value.(*LiveCustomDurableInvocation) +} +func (self CustomDurableInvocation) Replayed() PersistedDurableFunctionInvocation { + if self.tag != CustomDurableInvocationReplayed { + panic("tag mismatch") + } + return self.value.(PersistedDurableFunctionInvocation) +} + +func MakeCustomDurableInvocationLive(value *LiveCustomDurableInvocation) CustomDurableInvocation { + return CustomDurableInvocation{CustomDurableInvocationLive, value} +} +func MakeCustomDurableInvocationReplayed(value PersistedDurableFunctionInvocation) CustomDurableInvocation { + return CustomDurableInvocation{CustomDurableInvocationReplayed, value} +} + +//go:wasmimport golem:durability/durability@1.6.0 [static]live-custom-durable-invocation.finish +func wasm_import_static_live_custom_durable_invocation_finish(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 int32, arg6 uintptr, arg7 uint32, arg8 int32, arg9 int32) + +func LiveCustomDurableInvocationFinish(this *LiveCustomDurableInvocation, response golem_core_types.TypedSchemaValue, forcedCommit bool) { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + slice115 := ((response).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)) + 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result103 int32 + if (payload).Polymorphic { + result103 = 1 + } else { + result103 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result103) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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") + } + + } + + slice120 := ((response).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 + + } + + slice151 := ((response).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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + var result154 int32 + if forcedCommit { + result154 = 1 + } else { + result154 = 0 + } + wasm_import_static_live_custom_durable_invocation_finish((this).TakeHandle(), uintptr(result116), length117, uintptr(result121), length122, ((response).Graph).Root, uintptr(result152), length153, ((response).Value).Root, result154) + +} + +//go:wasmimport golem:durability/durability@1.6.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.6.0 begin-custom-durable-invocation +func wasm_import_begin_custom_durable_invocation(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32, arg4 uintptr, arg5 uint32, arg6 int32, arg7 uintptr, arg8 uint32, arg9 int32, arg10 int32, arg11 int32, arg12 int64, arg13 uintptr) + +func BeginCustomDurableInvocation(functionName string, request golem_core_types.TypedSchemaValue, functionType golem_api_oplog.WrappedFunctionType) CustomDurableInvocation { + pinner := &runtime.Pinner{} + defer pinner.Unpin() + + returnArea := uintptr(witRuntime.Allocate(pinner, (56 + 10*4), 8)) + utf8 := unsafe.Pointer(unsafe.StringData(functionName)) + pinner.Pin(utf8) + slice116 := ((request).Graph).TypeNodes + length118 := uint32(len(slice116)) + result117 := witRuntime.Allocate(pinner, uintptr(length118*(56+22*4)), 8) + for index, element := range slice116 { + base := unsafe.Add(result117, 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result104 int32 + if (payload).Polymorphic { + result104 = 1 + } else { + result104 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result104) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8105 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8105) + *(*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(utf8105))) + + default: + panic("unreachable") + } + slice107 := ((element).Metadata).Aliases + 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), (56 + 12*4))) = uint32(length109) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result108))) + slice111 := ((element).Metadata).Examples + length113 := uint32(len(slice111)) + result112 := witRuntime.Allocate(pinner, uintptr(length113*(2*4)), 4) + for index, element := range slice111 { + base := unsafe.Add(result112, index*(2*4)) + utf8110 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8110) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8110))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length113) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result112))) + + 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)) + utf8114 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8114) + *(*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(utf8114))) + + 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)) + utf8115 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8115) + *(*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(utf8115))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + slice121 := ((request).Graph).Defs + length123 := uint32(len(slice121)) + result122 := witRuntime.Allocate(pinner, uintptr(length123*(6*4)), 4) + for index, element := range slice121 { + base := unsafe.Add(result122, index*(6*4)) + utf8119 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8119) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8119))) + + 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)) + utf8120 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8120) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8120))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + slice152 := ((request).Value).ValueNodes + length154 := uint32(len(slice152)) + result153 := witRuntime.Allocate(pinner, uintptr(length154*(16+4*4)), 8) + for index, element := range slice152 { + base := unsafe.Add(result153, 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 result124 int32 + if payload { + result124 = 1 + } else { + result124 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result124) + + 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)) + utf8125 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8125) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8125))) + + case golem_core_types.SchemaValueNodeRecordValue: + payload := element.RecordValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13)) + slice126 := payload + length128 := uint32(len(slice126)) + result127 := witRuntime.Allocate(pinner, uintptr(length128*4), 4) + for index, element := range slice126 { + base := unsafe.Add(result127, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length128) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result127))) + + 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)) + slice130 := payload + length132 := uint32(len(slice130)) + result131 := witRuntime.Allocate(pinner, uintptr(length132*1), 1) + for index, element := range slice130 { + base := unsafe.Add(result131, index*1) + var result129 int32 + if element { + result129 = 1 + } else { + result129 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result129) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length132) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result131))) + + case golem_core_types.SchemaValueNodeTupleValue: + payload := element.TupleValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + slice133 := payload + length135 := uint32(len(slice133)) + result134 := witRuntime.Allocate(pinner, uintptr(length135*4), 4) + for index, element := range slice133 { + base := unsafe.Add(result134, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length135) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result134))) + + case golem_core_types.SchemaValueNodeListValue: + payload := element.ListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + slice136 := payload + length138 := uint32(len(slice136)) + result137 := witRuntime.Allocate(pinner, uintptr(length138*4), 4) + for index, element := range slice136 { + base := unsafe.Add(result137, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*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.SchemaValueNodeFixedListValue: + payload := element.FixedListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19)) + slice139 := payload + length141 := uint32(len(slice139)) + result140 := witRuntime.Allocate(pinner, uintptr(length141*4), 4) + for index, element := range slice139 { + base := unsafe.Add(result140, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length141) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result140))) + + case golem_core_types.SchemaValueNodeMapValue: + payload := element.MapValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20)) + slice142 := payload + length144 := uint32(len(slice142)) + result143 := witRuntime.Allocate(pinner, uintptr(length144*8), 4) + for index, element := range slice142 { + base := unsafe.Add(result143, 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(length144) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result143))) + + 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)) + utf8145 := unsafe.Pointer(unsafe.StringData((payload).Text)) + pinner.Pin(utf8145) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8145))) + + 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)) + 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.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)) + utf8147 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8147) + *(*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(utf8147))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaValueNodePathValue: + payload := element.PathValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25)) + 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.SchemaValueNodeUrlValue: + payload := element.UrlValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26)) + utf8149 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8149) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8149))) + + 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 + utf8150 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8150) + *(*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(utf8150))) + + case golem_core_types.SchemaValueNodeUnionValue: + payload := element.UnionValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30)) + utf8151 := unsafe.Pointer(unsafe.StringData((payload).Tag)) + pinner.Pin(utf8151) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8151))) + *(*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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + var variant int32 + var variant158 int32 + var variant159 int64 + switch functionType.Tag() { + case golem_api_oplog.WrappedFunctionTypeReadLocal: + + variant = int32(0) + variant158 = 0 + variant159 = 0 + + case golem_api_oplog.WrappedFunctionTypeWriteLocal: + + variant = int32(1) + variant158 = 0 + variant159 = 0 + + case golem_api_oplog.WrappedFunctionTypeReadRemote: + + variant = int32(2) + variant158 = 0 + variant159 = 0 + + case golem_api_oplog.WrappedFunctionTypeWriteRemote: + + variant = int32(3) + variant158 = 0 + variant159 = 0 + + case golem_api_oplog.WrappedFunctionTypeWriteRemoteBatched: + payload := functionType.WriteRemoteBatched() + var option int32 + var option155 int64 + switch payload.Tag() { + case witTypes.OptionNone: + + option = int32(0) + option155 = 0 + case witTypes.OptionSome: + payload := payload.Some() + + option = int32(1) + option155 = int64(payload) + default: + panic("unreachable") + } + + variant = int32(4) + variant158 = option + variant159 = option155 + + case golem_api_oplog.WrappedFunctionTypeWriteRemoteTransaction: + payload := functionType.WriteRemoteTransaction() + var option156 int32 + var option157 int64 + switch payload.Tag() { + case witTypes.OptionNone: + + option156 = int32(0) + option157 = 0 + case witTypes.OptionSome: + payload := payload.Some() + + option156 = int32(1) + option157 = int64(payload) + default: + panic("unreachable") + } + + variant = int32(5) + variant158 = option156 + variant159 = option157 + + default: + panic("unreachable") + } + wasm_import_begin_custom_durable_invocation(uintptr(utf8), uint32(len(functionName)), uintptr(result117), length118, uintptr(result122), length123, ((request).Graph).Root, uintptr(result153), length154, ((request).Value).Root, variant, variant158, variant159, returnArea) + var variant367 CustomDurableInvocation + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + + variant367 = MakeCustomDurableInvocationLive(LiveCustomDurableInvocationFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))) + + 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)))) + result335 := make([]golem_core_types.SchemaTypeNode, 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*(56+22*4)) + var variant323 golem_core_types.SchemaTypeBody + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant323 = golem_core_types.MakeSchemaTypeBodyRefType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 1: + + variant323 = golem_core_types.MakeSchemaTypeBodyBoolType() + + case 2: + var option166 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option166 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option161 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option161 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant160 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant160 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant160 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant160 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option161 = witTypes.Some[golem_core_types.NumericBound](variant160) + default: + panic("unreachable") + } + var option163 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option163 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant162 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant162 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant162 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant162 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option163 = witTypes.Some[golem_core_types.NumericBound](variant162) + default: + panic("unreachable") + } + var option165 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option165 = witTypes.None[string]() + case 1: + value164 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option165 = witTypes.Some[string](value164) + default: + panic("unreachable") + } + + option166 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option161, option163, option165}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyS8Type(option166) + + case 3: + var option173 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option173 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option168 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option168 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant167 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant167 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant167 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant167 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option168 = witTypes.Some[golem_core_types.NumericBound](variant167) + default: + panic("unreachable") + } + var option170 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option170 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant169 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant169 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant169 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant169 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option170 = witTypes.Some[golem_core_types.NumericBound](variant169) + default: + panic("unreachable") + } + var option172 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option172 = witTypes.None[string]() + case 1: + value171 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option172 = witTypes.Some[string](value171) + default: + panic("unreachable") + } + + option173 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option168, option170, option172}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyS16Type(option173) + + case 4: + var option180 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option180 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option175 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option175 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant174 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant174 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant174 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant174 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option175 = witTypes.Some[golem_core_types.NumericBound](variant174) + default: + panic("unreachable") + } + var option177 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option177 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant176 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant176 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant176 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant176 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option177 = witTypes.Some[golem_core_types.NumericBound](variant176) + default: + panic("unreachable") + } + var option179 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option179 = witTypes.None[string]() + case 1: + value178 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option179 = witTypes.Some[string](value178) + default: + panic("unreachable") + } + + option180 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option175, option177, option179}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyS32Type(option180) + + case 5: + var option187 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option187 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option182 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option182 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant181 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant181 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant181 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant181 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option182 = witTypes.Some[golem_core_types.NumericBound](variant181) + default: + panic("unreachable") + } + var option184 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option184 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant183 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant183 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant183 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant183 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option184 = witTypes.Some[golem_core_types.NumericBound](variant183) + default: + panic("unreachable") + } + var option186 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option186 = witTypes.None[string]() + case 1: + value185 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option186 = witTypes.Some[string](value185) + default: + panic("unreachable") + } + + option187 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option182, option184, option186}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyS64Type(option187) + + case 6: + var option194 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option194 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option189 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option189 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant188 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant188 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant188 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant188 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option189 = witTypes.Some[golem_core_types.NumericBound](variant188) + default: + panic("unreachable") + } + var option191 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option191 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant190 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant190 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant190 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant190 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option191 = witTypes.Some[golem_core_types.NumericBound](variant190) + default: + panic("unreachable") + } + var option193 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option193 = witTypes.None[string]() + case 1: + value192 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option193 = witTypes.Some[string](value192) + default: + panic("unreachable") + } + + option194 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option189, option191, option193}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyU8Type(option194) + + case 7: + var option201 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option201 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option196 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option196 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant195 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant195 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant195 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant195 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option196 = witTypes.Some[golem_core_types.NumericBound](variant195) + default: + panic("unreachable") + } + var option198 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option198 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant197 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant197 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant197 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant197 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option198 = witTypes.Some[golem_core_types.NumericBound](variant197) + default: + panic("unreachable") + } + var option200 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option200 = witTypes.None[string]() + case 1: + value199 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option200 = witTypes.Some[string](value199) + default: + panic("unreachable") + } + + option201 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option196, option198, option200}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyU16Type(option201) + + case 8: + var option208 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option208 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option203 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option203 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant202 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant202 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant202 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant202 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option203 = witTypes.Some[golem_core_types.NumericBound](variant202) + default: + panic("unreachable") + } + var option205 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option205 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant204 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant204 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant204 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant204 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option205 = witTypes.Some[golem_core_types.NumericBound](variant204) + default: + panic("unreachable") + } + var option207 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option207 = witTypes.None[string]() + case 1: + value206 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option207 = witTypes.Some[string](value206) + default: + panic("unreachable") + } + + option208 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option203, option205, option207}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyU32Type(option208) + + case 9: + var option215 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option215 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option210 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option210 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant209 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant209 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant209 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant209 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option210 = witTypes.Some[golem_core_types.NumericBound](variant209) + default: + panic("unreachable") + } + var option212 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + case 0: + + option212 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant211 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 48))) { + case 0: + + variant211 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant211 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant211 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option212 = witTypes.Some[golem_core_types.NumericBound](variant211) + default: + panic("unreachable") + } + var option214 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option214 = witTypes.None[string]() + case 1: + value213 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option214 = witTypes.Some[string](value213) + default: + panic("unreachable") + } + + option215 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option210, option212, option214}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyU64Type(option215) + + case 10: + var option222 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option222 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option217 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option217 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant216 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant216 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant216 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant216 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option217 = witTypes.Some[golem_core_types.NumericBound](variant216) + default: + panic("unreachable") + } + var option219 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant218 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant218 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant218 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option219 = witTypes.Some[golem_core_types.NumericBound](variant218) + default: + panic("unreachable") + } + var option221 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option221 = witTypes.None[string]() + case 1: + value220 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option221 = witTypes.Some[string](value220) + default: + panic("unreachable") + } + + option222 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option217, option219, option221}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyF32Type(option222) + + case 11: + var option229 witTypes.Option[golem_core_types.NumericRestrictions] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option229 = witTypes.None[golem_core_types.NumericRestrictions]() + case 1: + var option224 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option224 = witTypes.None[golem_core_types.NumericBound]() + case 1: + var variant223 golem_core_types.NumericBound + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 24))) { + case 0: + + variant223 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32))) + + case 1: + + variant223 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + case 2: + + variant223 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 32)))) + + default: + panic("unreachable") + } + + option224 = witTypes.Some[golem_core_types.NumericBound](variant223) + default: + panic("unreachable") + } + var option226 witTypes.Option[golem_core_types.NumericBound] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 40))) { + 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), 48))) { + case 0: + + variant225 = golem_core_types.MakeNumericBoundSigned(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56))) + + case 1: + + variant225 = golem_core_types.MakeNumericBoundUnsigned(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + case 2: + + variant225 = golem_core_types.MakeNumericBoundFloatBits(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 56)))) + + default: + panic("unreachable") + } + + option226 = witTypes.Some[golem_core_types.NumericBound](variant225) + default: + panic("unreachable") + } + var option228 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 64))) { + case 0: + + option228 = witTypes.None[string]() + case 1: + value227 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (64 + 2*4)))) + + option228 = witTypes.Some[string](value227) + default: + panic("unreachable") + } + + option229 = witTypes.Some[golem_core_types.NumericRestrictions](golem_core_types.NumericRestrictions{option224, option226, option228}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyF64Type(option229) + + case 12: + + variant323 = golem_core_types.MakeSchemaTypeBodyCharType() + + case 13: + + variant323 = golem_core_types.MakeSchemaTypeBodyStringType() + + case 14: + result242 := 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)) + value230 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option232 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + + option232 = witTypes.None[string]() + case 1: + value231 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + option232 = witTypes.Some[string](value231) + default: + panic("unreachable") + } + result234 := 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)) + value233 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result234 = append(result234, value233) + } + + result236 := 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)) + value235 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result236 = append(result236, value235) + } + + var option238 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))) { + case 0: + + option238 = witTypes.None[string]() + case 1: + value237 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4)))) + + option238 = witTypes.Some[string](value237) + default: + panic("unreachable") + } + var option241 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4)))) { + case 0: + + option241 = witTypes.None[golem_core_types.Role]() + case 1: + var variant240 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4)))) { + case 0: + + variant240 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant240 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant240 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value239 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) + + variant240 = golem_core_types.MakeRoleOther(value239) + + default: + panic("unreachable") + } + + option241 = witTypes.Some[golem_core_types.Role](variant240) + default: + panic("unreachable") + } + + result242 = append(result242, golem_core_types.NamedFieldType{value230, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), golem_core_types.MetadataEnvelope{option232, result234, result236, option238, option241}}) + } + + variant323 = golem_core_types.MakeSchemaTypeBodyRecordType(result242) + + case 15: + result256 := 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)) + value243 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option244 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option244 = witTypes.None[int32]() + case 1: + + option244 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), (4 + 2*4)))) + default: + panic("unreachable") + } + var option246 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option246 = witTypes.None[string]() + case 1: + value245 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option246 = witTypes.Some[string](value245) + default: + panic("unreachable") + } + result248 := 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)) + value247 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result248 = append(result248, value247) + } + + result250 := 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)) + value249 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result250 = append(result250, value249) + } + + var option252 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 9*4)))) { + case 0: + + option252 = witTypes.None[string]() + case 1: + value251 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 10*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 11*4)))) + + option252 = witTypes.Some[string](value251) + default: + panic("unreachable") + } + var option255 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 12*4)))) { + case 0: + + option255 = witTypes.None[golem_core_types.Role]() + case 1: + var variant254 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 13*4)))) { + case 0: + + variant254 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant254 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant254 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value253 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 14*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 15*4)))) + + variant254 = golem_core_types.MakeRoleOther(value253) + + default: + panic("unreachable") + } + + option255 = witTypes.Some[golem_core_types.Role](variant254) + default: + panic("unreachable") + } + + result256 = append(result256, golem_core_types.VariantCaseType{value243, option244, golem_core_types.MetadataEnvelope{option246, result248, result250, option252, option255}}) + } + + variant323 = golem_core_types.MakeSchemaTypeBodyVariantType(result256) + + case 16: + result258 := 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)) + value257 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result258 = append(result258, value257) + } + + variant323 = golem_core_types.MakeSchemaTypeBodyEnumType(result258) + + case 17: + result260 := 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)) + value259 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result260 = append(result260, value259) + } + + variant323 = golem_core_types.MakeSchemaTypeBodyFlagsType(result260) + + case 18: + result261 := 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) + + result261 = append(result261, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant323 = golem_core_types.MakeSchemaTypeBodyTupleType(result261) + + case 19: + + variant323 = golem_core_types.MakeSchemaTypeBodyListType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 20: + + variant323 = 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: + + variant323 = golem_core_types.MakeSchemaTypeBodyMapType(golem_core_types.MapSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 12))}) + + case 22: + + variant323 = golem_core_types.MakeSchemaTypeBodyOptionType(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 23: + var option262 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option262 = witTypes.None[int32]() + case 1: + + option262 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + var option263 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 16))) { + case 0: + + option263 = witTypes.None[int32]() + case 1: + + option263 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 20))) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyResultType(golem_core_types.ResultSpec{option262, option263}) + + case 24: + var option266 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option266 = witTypes.None[[]string]() + case 1: + result265 := 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)) + value264 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result265 = append(result265, value264) + } + + option266 = witTypes.Some[[]string](result265) + default: + panic("unreachable") + } + var option267 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option267 = witTypes.None[uint32]() + case 1: + + option267 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option268 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option268 = witTypes.None[uint32]() + case 1: + + option268 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + var option270 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 3*4)))) { + case 0: + + option270 = witTypes.None[string]() + case 1: + value269 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 4*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))) + + option270 = witTypes.Some[string](value269) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyTextType(golem_core_types.TextRestrictions{option266, option267, option268, option270}) + + case 25: + var option273 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option273 = witTypes.None[[]string]() + case 1: + result272 := 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)) + value271 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result272 = append(result272, value271) + } + + option273 = witTypes.Some[[]string](result272) + default: + panic("unreachable") + } + var option274 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option274 = witTypes.None[uint32]() + case 1: + + option274 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (12 + 3*4))))) + default: + panic("unreachable") + } + var option275 witTypes.Option[uint32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 3*4)))) { + case 0: + + option275 = witTypes.None[uint32]() + case 1: + + option275 = witTypes.Some[uint32](uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), (20 + 3*4))))) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyBinaryType(golem_core_types.BinaryRestrictions{option273, option274, option275}) + + case 26: + var option278 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option278 = witTypes.None[[]string]() + case 1: + result277 := 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)) + value276 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result277 = append(result277, value276) + } + + option278 = witTypes.Some[[]string](result277) + default: + panic("unreachable") + } + var option281 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option281 = witTypes.None[[]string]() + case 1: + result280 := 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)) + 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) + } + + option281 = witTypes.Some[[]string](result280) + default: + panic("unreachable") + } + + variant323 = 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)))), option278, option281}) + + case 27: + var option284 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option284 = witTypes.None[[]string]() + case 1: + result283 := 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)) + value282 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result283 = append(result283, value282) + } + + option284 = witTypes.Some[[]string](result283) + default: + panic("unreachable") + } + var option287 witTypes.Option[[]string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) { + case 0: + + option287 = witTypes.None[[]string]() + case 1: + result286 := 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)) + value285 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result286 = append(result286, value285) + } + + option287 = witTypes.Some[[]string](result286) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyUrlType(golem_core_types.UrlRestrictions{option284, option287}) + + case 28: + + variant323 = golem_core_types.MakeSchemaTypeBodyDatetimeType() + + case 29: + + variant323 = golem_core_types.MakeSchemaTypeBodyDurationType() + + case 30: + value288 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + result290 := 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)) + value289 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result290 = append(result290, value289) + } + + var option292 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) { + case 0: + + option292 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value291 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 5*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 + 6*4)))) + + option292 = 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))), value291}) + default: + panic("unreachable") + } + var option294 witTypes.Option[golem_core_types.QuantityValue] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 6*4)))) { + case 0: + + option294 = witTypes.None[golem_core_types.QuantityValue]() + case 1: + value293 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 7*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (48 + 8*4)))) + + option294 = 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))), value293}) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyQuantityType(golem_core_types.QuantitySpec{value288, result290, option292, option294}) + + case 31: + result316 := 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)) + value295 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var variant304 golem_core_types.DiscriminatorRule + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))) { + case 0: + value296 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant304 = golem_core_types.MakeDiscriminatorRulePrefix(value296) + + case 1: + value297 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant304 = golem_core_types.MakeDiscriminatorRuleSuffix(value297) + + case 2: + value298 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant304 = golem_core_types.MakeDiscriminatorRuleContains(value298) + + case 3: + value299 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant304 = golem_core_types.MakeDiscriminatorRuleRegex(value299) + + case 4: + value300 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + var option302 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4)))) { + case 0: + + option302 = witTypes.None[string]() + case 1: + value301 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4)))) + + option302 = witTypes.Some[string](value301) + default: + panic("unreachable") + } + + variant304 = golem_core_types.MakeDiscriminatorRuleFieldEquals(golem_core_types.FieldDiscriminator{value300, option302}) + + case 5: + value303 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))) + + variant304 = golem_core_types.MakeDiscriminatorRuleFieldAbsent(value303) + + default: + panic("unreachable") + } + var option306 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4)))) { + case 0: + + option306 = witTypes.None[string]() + case 1: + value305 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4)))) + + option306 = witTypes.Some[string](value305) + default: + panic("unreachable") + } + result308 := 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)) + 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) + } + + result310 := 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)) + value309 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result310 = append(result310, value309) + } + + var option312 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4)))) { + case 0: + + option312 = witTypes.None[string]() + case 1: + value311 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4)))) + + option312 = witTypes.Some[string](value311) + default: + panic("unreachable") + } + var option315 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4)))) { + case 0: + + option315 = witTypes.None[golem_core_types.Role]() + case 1: + var variant314 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4)))) { + case 0: + + variant314 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant314 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant314 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value313 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4)))) + + variant314 = golem_core_types.MakeRoleOther(value313) + + default: + panic("unreachable") + } + + option315 = witTypes.Some[golem_core_types.Role](variant314) + default: + panic("unreachable") + } + + result316 = append(result316, golem_core_types.UnionBranch{value295, *(*int32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))), variant304, golem_core_types.MetadataEnvelope{option306, result308, result310, option312, option315}}) + } + + variant323 = golem_core_types.MakeSchemaTypeBodyUnionType(golem_core_types.UnionSpec{result316}) + + case 32: + var option318 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) { + case 0: + + option318 = witTypes.None[string]() + case 1: + value317 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))) + + option318 = witTypes.Some[string](value317) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodySecretType(golem_core_types.SecretSpec{*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)), option318}) + + case 33: + var option320 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option320 = witTypes.None[string]() + case 1: + value319 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) + + option320 = witTypes.Some[string](value319) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyQuotaTokenType(golem_core_types.QuotaTokenSpec{option320}) + + case 34: + + variant323 = golem_core_types.MakeSchemaTypeBodyPermissionCardType(golem_core_types.PermissionCardSpec{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)}) + + case 35: + var option321 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option321 = witTypes.None[int32]() + case 1: + + option321 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyFutureType(option321) + + case 36: + var option322 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option322 = witTypes.None[int32]() + case 1: + + option322 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant323 = golem_core_types.MakeSchemaTypeBodyStreamType(option322) + + default: + panic("unreachable") + } + var option325 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 8*4)))) { + case 0: + + option325 = witTypes.None[string]() + case 1: + value324 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 9*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 10*4)))) + + option325 = witTypes.Some[string](value324) + default: + panic("unreachable") + } + result327 := 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)) + value326 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + + result327 = append(result327, value326) + } + + result329 := 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)) + 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) + } + + var option331 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 15*4)))) { + case 0: + + option331 = witTypes.None[string]() + case 1: + value330 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 16*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 17*4)))) + + option331 = witTypes.Some[string](value330) + default: + panic("unreachable") + } + var option334 witTypes.Option[golem_core_types.Role] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 18*4)))) { + case 0: + + option334 = witTypes.None[golem_core_types.Role]() + case 1: + var variant333 golem_core_types.Role + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 19*4)))) { + case 0: + + variant333 = golem_core_types.MakeRoleMultimodal() + + case 1: + + variant333 = golem_core_types.MakeRoleUnstructuredText() + + case 2: + + variant333 = golem_core_types.MakeRoleUnstructuredBinary() + + case 3: + value332 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 20*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 21*4)))) + + variant333 = golem_core_types.MakeRoleOther(value332) + + default: + panic("unreachable") + } + + option334 = witTypes.Some[golem_core_types.Role](variant333) + default: + panic("unreachable") + } + + result335 = append(result335, golem_core_types.SchemaTypeNode{variant323, golem_core_types.MetadataEnvelope{option325, result327, result329, option331, option334}}) + } + + result339 := make([]golem_core_types.SchemaTypeDef, 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*(6*4)) + value336 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4))) + var option338 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4)))) { + case 0: + + option338 = witTypes.None[string]() + case 1: + value337 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4)))) + + option338 = witTypes.Some[string](value337) + default: + panic("unreachable") + } + + result339 = append(result339, golem_core_types.SchemaTypeDef{value336, option338, *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4)))}) + } + + result363 := make([]golem_core_types.SchemaValueNode, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 8*4)))) + for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 8*4)))); index++ { + base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 7*4))))), index*(16+4*4)) + var variant362 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant362 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant362 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant362 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant362 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant362 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant362 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant362 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant362 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant362 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant362 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant362 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant362 = golem_core_types.MakeSchemaValueNodeCharValue(rune(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 12: + value340 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant362 = golem_core_types.MakeSchemaValueNodeStringValue(value340) + + case 13: + result341 := 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) + + result341 = append(result341, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant362 = golem_core_types.MakeSchemaValueNodeRecordValue(result341) + + case 14: + var option342 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option342 = witTypes.None[int32]() + case 1: + + option342 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant362 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option342}) + + case 15: + + variant362 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result343 := 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) + + result343 = append(result343, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant362 = golem_core_types.MakeSchemaValueNodeFlagsValue(result343) + + case 17: + result344 := 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) + + result344 = append(result344, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant362 = golem_core_types.MakeSchemaValueNodeTupleValue(result344) + + case 18: + result345 := 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) + + result345 = append(result345, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant362 = golem_core_types.MakeSchemaValueNodeListValue(result345) + + case 19: + result346 := 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) + + result346 = append(result346, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant362 = golem_core_types.MakeSchemaValueNodeFixedListValue(result346) + + case 20: + result347 := 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) + + result347 = append(result347, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant362 = golem_core_types.MakeSchemaValueNodeMapValue(result347) + + case 21: + var option348 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option348 = witTypes.None[int32]() + case 1: + + option348 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant362 = golem_core_types.MakeSchemaValueNodeOptionValue(option348) + + case 22: + var variant351 golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + var option349 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option349 = witTypes.None[int32]() + case 1: + + option349 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant351 = golem_core_types.MakeResultValuePayloadOkValue(option349) + + case 1: + var option350 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option350 = witTypes.None[int32]() + case 1: + + option350 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant351 = golem_core_types.MakeResultValuePayloadErrValue(option350) + + default: + panic("unreachable") + } + + variant362 = golem_core_types.MakeSchemaValueNodeResultValue(variant351) + + case 23: + value352 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option354 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option354 = witTypes.None[string]() + case 1: + value353 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option354 = witTypes.Some[string](value353) + default: + panic("unreachable") + } + + variant362 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value352, option354}) + + case 24: + value355 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option357 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option357 = witTypes.None[string]() + case 1: + value356 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option357 = witTypes.Some[string](value356) + default: + panic("unreachable") + } + + variant362 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value355, option357}) + + case 25: + value358 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant362 = golem_core_types.MakeSchemaValueNodePathValue(value358) + + case 26: + value359 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant362 = golem_core_types.MakeSchemaValueNodeUrlValue(value359) + + case 27: + + variant362 = 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: + + variant362 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value360 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant362 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value360}) + + case 30: + value361 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant362 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value361, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant362 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant362 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant362 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result363 = append(result363, variant362) + } + + var variant366 golem_api_oplog.WrappedFunctionType + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 10*4)))) { + case 0: + + variant366 = golem_api_oplog.MakeWrappedFunctionTypeReadLocal() + + case 1: + + variant366 = golem_api_oplog.MakeWrappedFunctionTypeWriteLocal() + + case 2: + + variant366 = golem_api_oplog.MakeWrappedFunctionTypeReadRemote() + + case 3: + + variant366 = golem_api_oplog.MakeWrappedFunctionTypeWriteRemote() + + case 4: + var option364 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 10*4)))) { + case 0: + + option364 = witTypes.None[uint64]() + case 1: + + option364 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 10*4))))) + default: + panic("unreachable") + } + + variant366 = golem_api_oplog.MakeWrappedFunctionTypeWriteRemoteBatched(option364) + + case 5: + var option365 witTypes.Option[uint64] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (32 + 10*4)))) { + case 0: + + option365 = witTypes.None[uint64]() + case 1: + + option365 = witTypes.Some[uint64](uint64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), (40 + 10*4))))) + default: + panic("unreachable") + } + + variant366 = golem_api_oplog.MakeWrappedFunctionTypeWriteRemoteTransaction(option365) + + default: + panic("unreachable") + } + + variant367 = MakeCustomDurableInvocationReplayed(PersistedDurableFunctionInvocation{wasi_clocks_0_3_0_system_clock.Instant{*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 8)), uint32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 16)))}, value, golem_core_types.TypedSchemaValue{golem_core_types.SchemaGraph{result335, result339, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 6*4)))}, golem_core_types.SchemaValueTree{result363, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (24 + 9*4)))}}, variant366, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (48 + 10*4)))))}) + + default: + panic("unreachable") + } + result368 := variant367 + return result368 + +} 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..d68a792ce0 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_quota_types/wit_bindings.go @@ -0,0 +1,177 @@ +// 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.6.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:permissions@0.1.0 +// 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..6a41582fab --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_rdbms_ignite2/wit_bindings.go @@ -0,0 +1,2037 @@ +// 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.6.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:permissions@0.1.0 +// 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..78a9f1433d --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_rdbms_mysql/wit_bindings.go @@ -0,0 +1,4066 @@ +// 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.6.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:permissions@0.1.0 +// 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..2ece78b50a --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_rdbms_postgres/wit_bindings.go @@ -0,0 +1,10570 @@ +// 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.6.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:permissions@0.1.0 +// 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..940ba52433 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_rdbms_types/wit_bindings.go @@ -0,0 +1,108 @@ +// 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.6.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:permissions@0.1.0 +// 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..4ca452f5d5 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_secrets_reveal/wit_bindings.go @@ -0,0 +1,2405 @@ +// 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.6.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:permissions@0.1.0 +// 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)) + slice115 := (expected).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)) + 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result103 int32 + if (payload).Polymorphic { + result103 = 1 + } else { + result103 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result103) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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") + } + + } + + slice120 := (expected).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 + + } + + wasm_import_reveal((s).Handle(), uintptr(result116), length117, uintptr(result121), length122, (expected).Root, returnArea) + var result148 witTypes.Result[golem_core_types.SchemaValueTree, golem_secrets_types.SecretError] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) { + case 0: + result143 := 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 variant142 golem_core_types.SchemaValueNode + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) { + case 0: + + variant142 = golem_core_types.MakeSchemaValueNodeBoolValue((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) != 0)) + + case 1: + + variant142 = golem_core_types.MakeSchemaValueNodeS8Value(int8(int8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 2: + + variant142 = golem_core_types.MakeSchemaValueNodeS16Value(int16(int16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 3: + + variant142 = golem_core_types.MakeSchemaValueNodeS32Value(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 4: + + variant142 = golem_core_types.MakeSchemaValueNodeS64Value(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 5: + + variant142 = golem_core_types.MakeSchemaValueNodeU8Value(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 6: + + variant142 = golem_core_types.MakeSchemaValueNodeU16Value(uint16(uint16(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))) + + case 7: + + variant142 = golem_core_types.MakeSchemaValueNodeU32Value(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 8: + + variant142 = golem_core_types.MakeSchemaValueNodeU64Value(uint64(*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 9: + + variant142 = golem_core_types.MakeSchemaValueNodeF32Value(*(*float32)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 10: + + variant142 = golem_core_types.MakeSchemaValueNodeF64Value(*(*float64)(unsafe.Add(unsafe.Pointer(base), 8))) + + case 11: + + variant142 = 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)))) + + variant142 = golem_core_types.MakeSchemaValueNodeStringValue(value) + + case 13: + result123 := 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) + + result123 = append(result123, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant142 = golem_core_types.MakeSchemaValueNodeRecordValue(result123) + + 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") + } + + variant142 = golem_core_types.MakeSchemaValueNodeVariantValue(golem_core_types.VariantValuePayload{uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8))), option}) + + case 15: + + variant142 = golem_core_types.MakeSchemaValueNodeEnumValue(uint32(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))) + + case 16: + result124 := 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) + + result124 = append(result124, (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0))) != 0)) + } + + variant142 = golem_core_types.MakeSchemaValueNodeFlagsValue(result124) + + case 17: + 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))) + } + + variant142 = golem_core_types.MakeSchemaValueNodeTupleValue(result125) + + case 18: + 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))) + } + + variant142 = golem_core_types.MakeSchemaValueNodeListValue(result126) + + case 19: + result127 := 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) + + result127 = append(result127, *(*int32)(unsafe.Add(unsafe.Pointer(base), 0))) + } + + variant142 = golem_core_types.MakeSchemaValueNodeFixedListValue(result127) + + case 20: + result128 := 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) + + result128 = append(result128, golem_core_types.MapEntry{*(*int32)(unsafe.Add(unsafe.Pointer(base), 0)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 4))}) + } + + variant142 = golem_core_types.MakeSchemaValueNodeMapValue(result128) + + case 21: + var option129 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + + option129 = witTypes.None[int32]() + case 1: + + option129 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 12))) + default: + panic("unreachable") + } + + variant142 = golem_core_types.MakeSchemaValueNodeOptionValue(option129) + + case 22: + var variant golem_core_types.ResultValuePayload + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))) { + case 0: + 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.MakeResultValuePayloadOkValue(option130) + + case 1: + var option131 witTypes.Option[int32] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 12))) { + case 0: + + option131 = witTypes.None[int32]() + case 1: + + option131 = witTypes.Some[int32](*(*int32)(unsafe.Add(unsafe.Pointer(base), 16))) + default: + panic("unreachable") + } + + variant = golem_core_types.MakeResultValuePayloadErrValue(option131) + + default: + panic("unreachable") + } + + variant142 = golem_core_types.MakeSchemaValueNodeResultValue(variant) + + case 23: + value132 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + var option134 witTypes.Option[string] + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))) { + case 0: + + option134 = witTypes.None[string]() + case 1: + value133 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4)))) + + option134 = witTypes.Some[string](value133) + default: + panic("unreachable") + } + + variant142 = golem_core_types.MakeSchemaValueNodeTextValue(golem_core_types.TextValuePayload{value132, option134}) + + case 24: + value135 := unsafe.Slice((*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") + } + + variant142 = golem_core_types.MakeSchemaValueNodeBinaryValue(golem_core_types.BinaryValuePayload{value135, option137}) + + case 25: + value138 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant142 = golem_core_types.MakeSchemaValueNodePathValue(value138) + + case 26: + value139 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant142 = golem_core_types.MakeSchemaValueNodeUrlValue(value139) + + case 27: + + variant142 = 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: + + variant142 = golem_core_types.MakeSchemaValueNodeDurationValue(golem_core_types.DurationValuePayload{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8))}) + + case 29: + value140 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 1*4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 + 2*4)))) + + variant142 = golem_core_types.MakeSchemaValueNodeQuantityValueNode(golem_core_types.QuantityValue{*(*int64)(unsafe.Add(unsafe.Pointer(base), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(base), 16)), value140}) + + case 30: + value141 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(base), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4)))) + + variant142 = golem_core_types.MakeSchemaValueNodeUnionValue(golem_core_types.UnionValuePayload{value141, *(*int32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4)))}) + + case 31: + + variant142 = golem_core_types.MakeSchemaValueNodeSecretValue(golem_core_types.SecretFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 32: + + variant142 = golem_core_types.MakeSchemaValueNodeQuotaTokenHandle(golem_core_types.QuotaTokenFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + case 33: + + variant142 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 8)))))) + + default: + panic("unreachable") + } + + result143 = append(result143, variant142) + } + + result148 = witTypes.Ok[golem_core_types.SchemaValueTree, golem_secrets_types.SecretError](golem_core_types.SchemaValueTree{result143, *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))}) + case 1: + var variant147 golem_secrets_types.SecretError + switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) { + case 0: + value144 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant147 = golem_secrets_types.MakeSecretErrorUnavailable(value144) + + case 1: + value145 := unsafe.Slice((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant147 = golem_secrets_types.MakeSecretErrorVersionNotFound(golem_secrets_types.SecretVersion{value145}) + + case 2: + value146 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) + + variant147 = golem_secrets_types.MakeSecretErrorInternal(value146) + + default: + panic("unreachable") + } + + result148 = witTypes.Err[golem_core_types.SchemaValueTree, golem_secrets_types.SecretError](variant147) + default: + panic("unreachable") + } + result149 := result148 + return result149 + +} 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..91fcf56c41 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_secrets_types/wit_bindings.go @@ -0,0 +1,207 @@ +// 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.6.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:permissions@0.1.0 +// 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..380af07dd1 --- /dev/null +++ b/sdks/go/golem/internal/wit/golem_websocket_client/wit_bindings.go @@ -0,0 +1,692 @@ +// 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.6.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:permissions@0.1.0 +// 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..c5d0005274 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_blobstore_blobstore/wit_bindings.go @@ -0,0 +1,227 @@ +// 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.6.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:permissions@0.1.0 +// 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..3f445ae939 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_blobstore_container/wit_bindings.go @@ -0,0 +1,435 @@ +// 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.6.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:permissions@0.1.0 +// 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..8d6519d3e1 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_blobstore_types/wit_bindings.go @@ -0,0 +1,313 @@ +// 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.6.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:permissions@0.1.0 +// 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`. +// +// 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..ae947708e5 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_cli_0_3_0_environment/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.6.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:permissions@0.1.0 +// 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..986ba6c9d1 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_system_clock/wit_bindings.go @@ -0,0 +1,86 @@ +// 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.6.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:permissions@0.1.0 +// 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..0d320494a2 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_clocks_0_3_0_types/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.6.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:permissions@0.1.0 +// 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..ca96986fb2 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_config_store/wit_bindings.go @@ -0,0 +1,186 @@ +// 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.6.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:permissions@0.1.0 +// 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..a234bfc40a --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_http_0_3_0_client/wit_bindings.go @@ -0,0 +1,484 @@ +// 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.6.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:permissions@0.1.0 +// 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..b2f4747640 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_http_0_3_0_types/wit_bindings.go @@ -0,0 +1,4062 @@ +// 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.6.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:permissions@0.1.0 +// 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: +// +// +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..30f7038d4f --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual/wit_bindings.go @@ -0,0 +1,167 @@ +// 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.6.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:permissions@0.1.0 +// 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..a3e8a60f40 --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_keyvalue_eventual_batch/wit_bindings.go @@ -0,0 +1,209 @@ +// 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.6.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:permissions@0.1.0 +// 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..e2da786b4f --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_keyvalue_types/wit_bindings.go @@ -0,0 +1,410 @@ +// 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.6.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:permissions@0.1.0 +// 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`. +// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the +// value as a `stream`. +// +// 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..df5e41368e --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_keyvalue_wasi_keyvalue_error/wit_bindings.go @@ -0,0 +1,112 @@ +// 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.6.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:permissions@0.1.0 +// 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..8d92f7366f --- /dev/null +++ b/sdks/go/golem/internal/wit/wasi_logging_logging/wit_bindings.go @@ -0,0 +1,74 @@ +// 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.6.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:permissions@0.1.0 +// 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..f1dbbcc355 --- /dev/null +++ b/sdks/go/golem/internal/wit/wit_exports/wit_exports.go @@ -0,0 +1,19839 @@ +// 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.6.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:permissions@0.1.0 +// 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)))))) + + case 33: + + variant19 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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 option208 int32 + var option209 int32 + var option210 uintptr + var option211 uint32 + var option212 uintptr + var option213 uint32 + var option214 int32 + var option215 uintptr + var option216 uint32 + var option217 int32 + switch result39.Tag() { + case witTypes.ResultOk: + + option208 = int32(0) + option209 = 0 + option210 = 0 + option211 = 0 + option212 = 0 + option213 = 0 + option214 = 0 + option215 = 0 + option216 = 0 + option217 = 0 + case witTypes.ResultErr: + payload := result39.Err() + var variant199 int32 + var variant200 uintptr + var variant201 uint32 + var variant202 uintptr + var variant203 uint32 + var variant204 int32 + var variant205 uintptr + var variant206 uint32 + var variant207 int32 + switch payload.Tag() { + case golem_agent_common.AgentErrorInvalidInput: + payload := payload.InvalidInput() + utf8 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8) + + variant199 = int32(0) + variant200 = uintptr(utf8) + variant201 = uint32(len(payload)) + variant202 = 0 + variant203 = 0 + variant204 = 0 + variant205 = 0 + variant206 = 0 + variant207 = 0 + + case golem_agent_common.AgentErrorInvalidMethod: + payload := payload.InvalidMethod() + utf840 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf840) + + variant199 = int32(1) + variant200 = uintptr(utf840) + variant201 = uint32(len(payload)) + variant202 = 0 + variant203 = 0 + variant204 = 0 + variant205 = 0 + variant206 = 0 + variant207 = 0 + + case golem_agent_common.AgentErrorInvalidType: + payload := payload.InvalidType() + utf841 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf841) + + variant199 = int32(2) + variant200 = uintptr(utf841) + variant201 = uint32(len(payload)) + variant202 = 0 + variant203 = 0 + variant204 = 0 + variant205 = 0 + variant206 = 0 + variant207 = 0 + + case golem_agent_common.AgentErrorInvalidAgentId: + payload := payload.InvalidAgentId() + utf842 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf842) + + variant199 = int32(3) + variant200 = uintptr(utf842) + variant201 = uint32(len(payload)) + variant202 = 0 + variant203 = 0 + variant204 = 0 + variant205 = 0 + variant206 = 0 + variant207 = 0 + + case golem_agent_common.AgentErrorCustomError: + payload := payload.CustomError() + slice160 := ((payload).Graph).TypeNodes + length162 := uint32(len(slice160)) + result161 := witRuntime.Allocate(pinner, uintptr(length162*(56+22*4)), 8) + for index, element := range slice160 { + base := unsafe.Add(result161, 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result148 int32 + if (payload).Polymorphic { + result148 = 1 + } else { + result148 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result148) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8149 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8149) + *(*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(utf8149))) + + default: + panic("unreachable") + } + slice151 := ((element).Metadata).Aliases + length153 := uint32(len(slice151)) + result152 := witRuntime.Allocate(pinner, uintptr(length153*(2*4)), 4) + for index, element := range slice151 { + base := unsafe.Add(result152, index*(2*4)) + utf8150 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8150) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8150))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length153) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result152))) + slice155 := ((element).Metadata).Examples + length157 := uint32(len(slice155)) + result156 := witRuntime.Allocate(pinner, uintptr(length157*(2*4)), 4) + for index, element := range slice155 { + base := unsafe.Add(result156, index*(2*4)) + utf8154 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8154) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8154))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length157) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result156))) + + 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)) + utf8158 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8158) + *(*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(utf8158))) + + 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)) + utf8159 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8159) + *(*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(utf8159))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + slice165 := ((payload).Graph).Defs + length167 := uint32(len(slice165)) + result166 := witRuntime.Allocate(pinner, uintptr(length167*(6*4)), 4) + for index, element := range slice165 { + base := unsafe.Add(result166, index*(6*4)) + utf8163 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8163) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8163))) + + 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)) + utf8164 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8164) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8164))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + slice196 := ((payload).Value).ValueNodes + length198 := uint32(len(slice196)) + result197 := witRuntime.Allocate(pinner, uintptr(length198*(16+4*4)), 8) + for index, element := range slice196 { + base := unsafe.Add(result197, 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 result168 int32 + if payload { + result168 = 1 + } else { + result168 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result168) + + 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)) + utf8169 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8169) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8169))) + + case golem_core_types.SchemaValueNodeRecordValue: + payload := element.RecordValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13)) + slice170 := payload + length172 := uint32(len(slice170)) + result171 := witRuntime.Allocate(pinner, uintptr(length172*4), 4) + for index, element := range slice170 { + base := unsafe.Add(result171, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length172) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result171))) + + 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)) + slice174 := payload + length176 := uint32(len(slice174)) + result175 := witRuntime.Allocate(pinner, uintptr(length176*1), 1) + for index, element := range slice174 { + base := unsafe.Add(result175, index*1) + var result173 int32 + if element { + result173 = 1 + } else { + result173 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result173) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length176) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result175))) + + case golem_core_types.SchemaValueNodeTupleValue: + payload := element.TupleValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + slice177 := payload + length179 := uint32(len(slice177)) + result178 := witRuntime.Allocate(pinner, uintptr(length179*4), 4) + for index, element := range slice177 { + base := unsafe.Add(result178, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length179) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result178))) + + case golem_core_types.SchemaValueNodeListValue: + payload := element.ListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + slice180 := payload + length182 := uint32(len(slice180)) + result181 := witRuntime.Allocate(pinner, uintptr(length182*4), 4) + for index, element := range slice180 { + base := unsafe.Add(result181, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length182) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result181))) + + case golem_core_types.SchemaValueNodeFixedListValue: + payload := element.FixedListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19)) + slice183 := payload + length185 := uint32(len(slice183)) + result184 := witRuntime.Allocate(pinner, uintptr(length185*4), 4) + for index, element := range slice183 { + base := unsafe.Add(result184, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length185) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result184))) + + case golem_core_types.SchemaValueNodeMapValue: + payload := element.MapValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20)) + slice186 := payload + length188 := uint32(len(slice186)) + result187 := witRuntime.Allocate(pinner, uintptr(length188*8), 4) + for index, element := range slice186 { + base := unsafe.Add(result187, 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(length188) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result187))) + + 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)) + utf8189 := unsafe.Pointer(unsafe.StringData((payload).Text)) + pinner.Pin(utf8189) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8189))) + + 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)) + 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.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)) + utf8191 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8191) + *(*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(utf8191))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaValueNodePathValue: + payload := element.PathValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25)) + 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.SchemaValueNodeUrlValue: + payload := element.UrlValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26)) + utf8193 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8193) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8193))) + + 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 + utf8194 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8194) + *(*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(utf8194))) + + case golem_core_types.SchemaValueNodeUnionValue: + payload := element.UnionValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30)) + utf8195 := unsafe.Pointer(unsafe.StringData((payload).Tag)) + pinner.Pin(utf8195) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8195))) + *(*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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + variant199 = int32(4) + variant200 = uintptr(result161) + variant201 = length162 + variant202 = uintptr(result166) + variant203 = length167 + variant204 = ((payload).Graph).Root + variant205 = uintptr(result197) + variant206 = length198 + variant207 = ((payload).Value).Root + + default: + panic("unreachable") + } + + option208 = int32(1) + option209 = variant199 + option210 = variant200 + option211 = variant201 + option212 = variant202 + option213 = variant203 + option214 = variant204 + option215 = variant205 + option216 = variant206 + option217 = variant207 + default: + panic("unreachable") + } + wasm_export_task_return_golem_agent_guest_initialize(option208, option209, option210, option211, option212, option213, option214, option215, option216, option217) + + })) +} + +//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)))))) + + case 33: + + variant19 = golem_core_types.MakeSchemaValueNodePermissionCardHandle(golem_core_types.PermissionCardFromOwnHandle(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 option244 int32 + var option245 int32 + var option246 uintptr + var option247 uint32 + var option248 uintptr + var option249 uint32 + var option250 int32 + var option251 uintptr + var option252 uint32 + var option253 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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*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") + } + + option244 = int32(0) + option245 = option68 + option246 = option69 + option247 = option70 + option248 = uintptr(option71) + option249 = 0 + option250 = 0 + option251 = 0 + option252 = 0 + option253 = 0 + case witTypes.ResultErr: + payload := result39.Err() + var variant235 int32 + var variant236 uintptr + var variant237 uint32 + var variant238 uintptr + var variant239 uint32 + var variant240 int32 + var variant241 uintptr + var variant242 uint32 + var variant243 int32 + switch payload.Tag() { + case golem_agent_common.AgentErrorInvalidInput: + payload := payload.InvalidInput() + utf872 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf872) + + variant235 = int32(0) + variant236 = uintptr(utf872) + variant237 = uint32(len(payload)) + variant238 = 0 + variant239 = 0 + variant240 = 0 + variant241 = 0 + variant242 = 0 + variant243 = 0 + + case golem_agent_common.AgentErrorInvalidMethod: + payload := payload.InvalidMethod() + utf873 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf873) + + variant235 = int32(1) + variant236 = uintptr(utf873) + variant237 = uint32(len(payload)) + variant238 = 0 + variant239 = 0 + variant240 = 0 + variant241 = 0 + variant242 = 0 + variant243 = 0 + + case golem_agent_common.AgentErrorInvalidType: + payload := payload.InvalidType() + utf874 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf874) + + variant235 = int32(2) + variant236 = uintptr(utf874) + variant237 = uint32(len(payload)) + variant238 = 0 + variant239 = 0 + variant240 = 0 + variant241 = 0 + variant242 = 0 + variant243 = 0 + + case golem_agent_common.AgentErrorInvalidAgentId: + payload := payload.InvalidAgentId() + utf875 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf875) + + variant235 = int32(3) + variant236 = uintptr(utf875) + variant237 = uint32(len(payload)) + variant238 = 0 + variant239 = 0 + variant240 = 0 + variant241 = 0 + variant242 = 0 + variant243 = 0 + + case golem_agent_common.AgentErrorCustomError: + payload := payload.CustomError() + slice195 := ((payload).Graph).TypeNodes + length197 := uint32(len(slice195)) + result196 := witRuntime.Allocate(pinner, uintptr(length197*(56+22*4)), 8) + for index, element := range slice195 { + base := unsafe.Add(result196, 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result183 int32 + if (payload).Polymorphic { + result183 = 1 + } else { + result183 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result183) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8184 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8184) + *(*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(utf8184))) + + default: + panic("unreachable") + } + slice186 := ((element).Metadata).Aliases + 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), (56 + 12*4))) = uint32(length188) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result187))) + slice190 := ((element).Metadata).Examples + length192 := uint32(len(slice190)) + result191 := witRuntime.Allocate(pinner, uintptr(length192*(2*4)), 4) + for index, element := range slice190 { + base := unsafe.Add(result191, index*(2*4)) + utf8189 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8189) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8189))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length192) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result191))) + + 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)) + utf8193 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8193) + *(*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(utf8193))) + + 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)) + utf8194 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8194) + *(*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(utf8194))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + slice200 := ((payload).Graph).Defs + length202 := uint32(len(slice200)) + result201 := witRuntime.Allocate(pinner, uintptr(length202*(6*4)), 4) + for index, element := range slice200 { + base := unsafe.Add(result201, index*(6*4)) + utf8198 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8198) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8198))) + + 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)) + utf8199 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8199) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8199))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + slice232 := ((payload).Value).ValueNodes + length234 := uint32(len(slice232)) + result233 := witRuntime.Allocate(pinner, uintptr(length234*(16+4*4)), 8) + for index, element := range slice232 { + base := unsafe.Add(result233, 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 result203 int32 + if payload { + result203 = 1 + } else { + result203 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result203) + + 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)) + utf8204 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8204) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8204))) + + case golem_core_types.SchemaValueNodeRecordValue: + payload := element.RecordValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13)) + slice205 := payload + length207 := uint32(len(slice205)) + result206 := witRuntime.Allocate(pinner, uintptr(length207*4), 4) + for index, element := range slice205 { + base := unsafe.Add(result206, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length207) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result206))) + + 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)) + slice209 := payload + length211 := uint32(len(slice209)) + result210 := witRuntime.Allocate(pinner, uintptr(length211*1), 1) + for index, element := range slice209 { + base := unsafe.Add(result210, index*1) + var result208 int32 + if element { + result208 = 1 + } else { + result208 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result208) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length211) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result210))) + + case golem_core_types.SchemaValueNodeTupleValue: + payload := element.TupleValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + slice212 := payload + length214 := uint32(len(slice212)) + result213 := witRuntime.Allocate(pinner, uintptr(length214*4), 4) + for index, element := range slice212 { + base := unsafe.Add(result213, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length214) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result213))) + + case golem_core_types.SchemaValueNodeListValue: + payload := element.ListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + slice215 := payload + length217 := uint32(len(slice215)) + result216 := witRuntime.Allocate(pinner, uintptr(length217*4), 4) + for index, element := range slice215 { + base := unsafe.Add(result216, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*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.SchemaValueNodeFixedListValue: + payload := element.FixedListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19)) + slice218 := payload + length220 := uint32(len(slice218)) + result219 := witRuntime.Allocate(pinner, uintptr(length220*4), 4) + for index, element := range slice218 { + base := unsafe.Add(result219, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length220) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result219))) + + case golem_core_types.SchemaValueNodeMapValue: + payload := element.MapValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20)) + slice221 := payload + length223 := uint32(len(slice221)) + result222 := witRuntime.Allocate(pinner, uintptr(length223*8), 4) + for index, element := range slice221 { + base := unsafe.Add(result222, 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(length223) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result222))) + + 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)) + utf8224 := unsafe.Pointer(unsafe.StringData((payload).Text)) + pinner.Pin(utf8224) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8224))) + + 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)) + utf8225 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8225) + *(*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(utf8225))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaValueNodeBinaryValue: + payload := element.BinaryValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(24)) + data226 := unsafe.Pointer(unsafe.SliceData((payload).Bytes)) + pinner.Pin(data226) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Bytes))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(data226))) + + 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)) + utf8227 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8227) + *(*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(utf8227))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaValueNodePathValue: + payload := element.PathValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25)) + 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.SchemaValueNodeUrlValue: + payload := element.UrlValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26)) + utf8229 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8229) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8229))) + + 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 + utf8230 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8230) + *(*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(utf8230))) + + case golem_core_types.SchemaValueNodeUnionValue: + payload := element.UnionValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30)) + utf8231 := unsafe.Pointer(unsafe.StringData((payload).Tag)) + pinner.Pin(utf8231) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8231))) + *(*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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + variant235 = int32(4) + variant236 = uintptr(result196) + variant237 = length197 + variant238 = uintptr(result201) + variant239 = length202 + variant240 = ((payload).Graph).Root + variant241 = uintptr(result233) + variant242 = length234 + variant243 = ((payload).Value).Root + + default: + panic("unreachable") + } + + option244 = int32(1) + option245 = variant235 + option246 = variant236 + option247 = variant237 + option248 = variant238 + option249 = variant239 + option250 = variant240 + option251 = variant241 + option252 = variant242 + option253 = variant243 + default: + panic("unreachable") + } + wasm_export_task_return_golem_agent_guest_invoke(option244, option245, option246, option247, option248, option249, option250, option251, option252, option253) + + })) +} + +//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))) + slice119 := ((result).Schema).TypeNodes + length121 := uint32(len(slice119)) + result120 := witRuntime.Allocate(pinner, uintptr(length121*(56+22*4)), 8) + for index, element := range slice119 { + base := unsafe.Add(result120, 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result107 int32 + if (payload).Polymorphic { + result107 = 1 + } else { + result107 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result107) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8108 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8108) + *(*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(utf8108))) + + default: + panic("unreachable") + } + slice110 := ((element).Metadata).Aliases + 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 + 12*4))) = uint32(length112) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result111))) + slice114 := ((element).Metadata).Examples + 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), (56 + 14*4))) = uint32(length116) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result115))) + + 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)) + utf8117 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8117) + *(*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(utf8117))) + + 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)) + utf8118 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8118) + *(*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(utf8118))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (7 * 4))) = uint32(length121) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (6 * 4))) = uint32(uintptr(uintptr(result120))) + slice124 := ((result).Schema).Defs + length126 := uint32(len(slice124)) + result125 := witRuntime.Allocate(pinner, uintptr(length126*(6*4)), 4) + for index, element := range slice124 { + base := unsafe.Add(result125, index*(6*4)) + utf8122 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8122) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8122))) + + 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)) + utf8123 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8123) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8123))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (9 * 4))) = uint32(length126) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (8 * 4))) = uint32(uintptr(uintptr(result125))) + *(*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)) + utf8127 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8127) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (13 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (12 * 4))) = uint32(uintptr(uintptr(utf8127))) + + default: + panic("unreachable") + } + utf8128 := unsafe.Pointer(unsafe.StringData(((result).Constructor).Description)) + pinner.Pin(utf8128) + *(*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(utf8128))) + + 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)) + utf8129 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8129) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (18 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (17 * 4))) = uint32(uintptr(uintptr(utf8129))) + + 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)) + slice142 := payload + length144 := uint32(len(slice142)) + result143 := witRuntime.Allocate(pinner, uintptr(length144*(8+16*4)), 4) + for index, element := range slice142 { + base := unsafe.Add(result143, index*(8+16*4)) + utf8130 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8130) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8130))) + + 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)) + utf8131 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8131) + *(*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(utf8131))) + + default: + panic("unreachable") + } + slice133 := ((element).Metadata).Aliases + 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 + 6*4))) = uint32(length135) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result134))) + slice137 := ((element).Metadata).Examples + 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 + 8*4))) = uint32(length139) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result138))) + + 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)) + utf8140 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8140) + *(*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(utf8140))) + + 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)) + utf8141 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8141) + *(*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(utf8141))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (21 * 4))) = uint32(length144) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (20 * 4))) = uint32(uintptr(uintptr(result143))) + + default: + panic("unreachable") + } + slice189 := (result).Methods + length191 := uint32(len(slice189)) + result190 := witRuntime.Allocate(pinner, uintptr(length191*(40+12*4)), 8) + for index, element := range slice189 { + base := unsafe.Add(result190, index*(40+12*4)) + utf8145 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8145) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8145))) + utf8146 := unsafe.Pointer(unsafe.StringData((element).Description)) + pinner.Pin(utf8146) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8146))) + slice169 := (element).HttpEndpoint + length171 := uint32(len(slice169)) + result170 := witRuntime.Allocate(pinner, uintptr(length171*(12*4)), 4) + for index, element := range slice169 { + base := unsafe.Add(result170, 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)) + 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))) + + default: + panic("unreachable") + } + slice151 := (element).PathSuffix + length153 := uint32(len(slice151)) + result152 := witRuntime.Allocate(pinner, uintptr(length153*(3*4)), 4) + for index, element := range slice151 { + base := unsafe.Add(result152, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8148 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8148) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8148))) + + 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)) + 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))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8150 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8150) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8150))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length153) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result152))) + slice156 := (element).HeaderVars + length158 := uint32(len(slice156)) + result157 := witRuntime.Allocate(pinner, uintptr(length158*(4*4)), 4) + for index, element := range slice156 { + base := unsafe.Add(result157, index*(4*4)) + utf8154 := unsafe.Pointer(unsafe.StringData((element).HeaderName)) + pinner.Pin(utf8154) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8154))) + utf8155 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8155) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8155))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length158) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result157))) + slice161 := (element).QueryVars + length163 := uint32(len(slice161)) + result162 := witRuntime.Allocate(pinner, uintptr(length163*(4*4)), 4) + for index, element := range slice161 { + base := unsafe.Add(result162, index*(4*4)) + utf8159 := unsafe.Pointer(unsafe.StringData((element).QueryParamName)) + pinner.Pin(utf8159) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8159))) + utf8160 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8160) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8160))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length163) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result162))) + + 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 result164 int32 + if (payload).Required { + result164 = 1 + } else { + result164 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result164) + + default: + panic("unreachable") + } + slice166 := ((element).CorsOptions).AllowedPatterns + length168 := uint32(len(slice166)) + result167 := witRuntime.Allocate(pinner, uintptr(length168*(2*4)), 4) + for index, element := range slice166 { + base := unsafe.Add(result167, index*(2*4)) + utf8165 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8165) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8165))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length168) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result167))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length171) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result170))) + + 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)) + utf8172 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8172) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8172))) + + 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)) + slice185 := payload + length187 := uint32(len(slice185)) + result186 := witRuntime.Allocate(pinner, uintptr(length187*(8+16*4)), 4) + for index, element := range slice185 { + base := unsafe.Add(result186, index*(8+16*4)) + utf8173 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8173) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8173))) + + 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)) + utf8174 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8174) + *(*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(utf8174))) + + default: + panic("unreachable") + } + slice176 := ((element).Metadata).Aliases + length178 := uint32(len(slice176)) + result177 := witRuntime.Allocate(pinner, uintptr(length178*(2*4)), 4) + for index, element := range slice176 { + base := unsafe.Add(result177, index*(2*4)) + utf8175 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8175) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8175))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length178) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result177))) + slice180 := ((element).Metadata).Examples + length182 := uint32(len(slice180)) + result181 := witRuntime.Allocate(pinner, uintptr(length182*(2*4)), 4) + for index, element := range slice180 { + base := unsafe.Add(result181, index*(2*4)) + utf8179 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8179) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8179))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length182) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result181))) + + 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)) + utf8183 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8183) + *(*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(utf8183))) + + 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)) + utf8184 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8184) + *(*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(utf8184))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length187) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result186))) + + 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 result188 int32 + if (payload).UsesPrincipal { + result188 = 1 + } else { + result188 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result188) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (23 * 4))) = uint32(length191) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (22 * 4))) = uint32(uintptr(uintptr(result190))) + slice386 := (result).Dependencies + length388 := uint32(len(slice386)) + result387 := witRuntime.Allocate(pinner, uintptr(length388*(23*4)), 4) + for index, element := range slice386 { + base := unsafe.Add(result387, index*(23*4)) + utf8192 := unsafe.Pointer(unsafe.StringData((element).TypeName)) + pinner.Pin(utf8192) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).TypeName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8192))) + + 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)) + utf8193 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8193) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8193))) + + default: + panic("unreachable") + } + slice313 := ((element).Schema).TypeNodes + length315 := uint32(len(slice313)) + result314 := witRuntime.Allocate(pinner, uintptr(length315*(56+22*4)), 8) + for index, element := range slice313 { + base := unsafe.Add(result314, 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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + utf8203 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8203) + *(*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(utf8203))) + + 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)) + slice216 := payload + length218 := uint32(len(slice216)) + result217 := witRuntime.Allocate(pinner, uintptr(length218*(17*4)), 4) + for index, element := range slice216 { + base := unsafe.Add(result217, index*(17*4)) + utf8204 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8204) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8204))) + *(*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)) + utf8205 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8205) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8205))) + + default: + panic("unreachable") + } + slice207 := ((element).Metadata).Aliases + length209 := uint32(len(slice207)) + result208 := witRuntime.Allocate(pinner, uintptr(length209*(2*4)), 4) + for index, element := range slice207 { + base := unsafe.Add(result208, index*(2*4)) + utf8206 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8206) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8206))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length209) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result208))) + slice211 := ((element).Metadata).Examples + 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), (9 * 4))) = uint32(length213) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result212))) + + 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)) + utf8214 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8214) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8214))) + + 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)) + utf8215 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8215) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf8215))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length218) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result217))) + + case golem_core_types.SchemaTypeBodyVariantType: + payload := (element).Body.VariantType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15)) + slice231 := payload + length233 := uint32(len(slice231)) + result232 := witRuntime.Allocate(pinner, uintptr(length233*(8+16*4)), 4) + for index, element := range slice231 { + base := unsafe.Add(result232, index*(8+16*4)) + utf8219 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8219) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8219))) + + 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)) + utf8220 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8220) + *(*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(utf8220))) + + default: + panic("unreachable") + } + slice222 := ((element).Metadata).Aliases + length224 := uint32(len(slice222)) + result223 := witRuntime.Allocate(pinner, uintptr(length224*(2*4)), 4) + for index, element := range slice222 { + base := unsafe.Add(result223, index*(2*4)) + utf8221 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8221) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8221))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length224) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result223))) + slice226 := ((element).Metadata).Examples + length228 := uint32(len(slice226)) + result227 := witRuntime.Allocate(pinner, uintptr(length228*(2*4)), 4) + for index, element := range slice226 { + base := unsafe.Add(result227, index*(2*4)) + utf8225 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8225) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8225))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length228) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result227))) + + 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)) + utf8229 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8229) + *(*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(utf8229))) + + 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)) + utf8230 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8230) + *(*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(utf8230))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length233) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result232))) + + case golem_core_types.SchemaTypeBodyEnumType: + payload := (element).Body.EnumType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16)) + slice235 := payload + length237 := uint32(len(slice235)) + result236 := witRuntime.Allocate(pinner, uintptr(length237*(2*4)), 4) + for index, element := range slice235 { + base := unsafe.Add(result236, index*(2*4)) + utf8234 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8234) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8234))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length237) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result236))) + + case golem_core_types.SchemaTypeBodyFlagsType: + payload := (element).Body.FlagsType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + slice239 := payload + length241 := uint32(len(slice239)) + result240 := witRuntime.Allocate(pinner, uintptr(length241*(2*4)), 4) + for index, element := range slice239 { + base := unsafe.Add(result240, index*(2*4)) + utf8238 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8238) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8238))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length241) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result240))) + + case golem_core_types.SchemaTypeBodyTupleType: + payload := (element).Body.TupleType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + slice242 := payload + length244 := uint32(len(slice242)) + result243 := witRuntime.Allocate(pinner, uintptr(length244*4), 4) + for index, element := range slice242 { + base := unsafe.Add(result243, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length244) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result243))) + + 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)) + slice246 := payload + length248 := uint32(len(slice246)) + result247 := witRuntime.Allocate(pinner, uintptr(length248*(2*4)), 4) + for index, element := range slice246 { + base := unsafe.Add(result247, index*(2*4)) + utf8245 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8245) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8245))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length248) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result247))) + + 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)) + utf8249 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8249) + *(*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(utf8249))) + + 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)) + slice251 := payload + 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), (8 + 2*4))) = uint32(length253) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result252))) + + 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)) + slice255 := payload + length257 := uint32(len(slice255)) + result256 := witRuntime.Allocate(pinner, uintptr(length257*(2*4)), 4) + for index, element := range slice255 { + base := unsafe.Add(result256, index*(2*4)) + utf8254 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8254) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8254))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length257) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result256))) + + 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)) + slice259 := payload + length261 := uint32(len(slice259)) + result260 := witRuntime.Allocate(pinner, uintptr(length261*(2*4)), 4) + for index, element := range slice259 { + base := unsafe.Add(result260, index*(2*4)) + utf8258 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8258) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8258))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length261) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result260))) + + 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)) + slice263 := payload + 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), (8 + 2*4))) = uint32(length265) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result264))) + + 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)) + slice267 := payload + 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), (8 + 5*4))) = uint32(length269) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result268))) + + 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)) + utf8270 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit)) + pinner.Pin(utf8270) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8270))) + slice272 := (payload).AllowedSuffixes + length274 := uint32(len(slice272)) + result273 := witRuntime.Allocate(pinner, uintptr(length274*(2*4)), 4) + for index, element := range slice272 { + base := unsafe.Add(result273, index*(2*4)) + utf8271 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8271) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8271))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length274) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result273))) + + 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 + utf8275 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8275) + *(*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(utf8275))) + + 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 + utf8276 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8276) + *(*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(utf8276))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaTypeBodyUnionType: + payload := (element).Body.UnionType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31)) + slice296 := (payload).Branches + length298 := uint32(len(slice296)) + result297 := witRuntime.Allocate(pinner, uintptr(length298*(23*4)), 4) + for index, element := range slice296 { + base := unsafe.Add(result297, index*(23*4)) + utf8277 := unsafe.Pointer(unsafe.StringData((element).Tag)) + pinner.Pin(utf8277) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8277))) + *(*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)) + 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.DiscriminatorRuleSuffix: + payload := (element).Discriminator.Suffix() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1)) + 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.DiscriminatorRuleContains: + payload := (element).Discriminator.Contains() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2)) + 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.DiscriminatorRuleRegex: + payload := (element).Discriminator.Regex() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3)) + utf8281 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8281) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8281))) + + case golem_core_types.DiscriminatorRuleFieldEquals: + payload := (element).Discriminator.FieldEquals() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4)) + utf8282 := unsafe.Pointer(unsafe.StringData((payload).FieldName)) + pinner.Pin(utf8282) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8282))) + + 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)) + utf8283 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8283) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8283))) + + default: + panic("unreachable") + } + + case golem_core_types.DiscriminatorRuleFieldAbsent: + payload := (element).Discriminator.FieldAbsent() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5)) + utf8284 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8284) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8284))) + + 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)) + utf8285 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8285) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8285))) + + default: + panic("unreachable") + } + slice287 := ((element).Metadata).Aliases + length289 := uint32(len(slice287)) + result288 := witRuntime.Allocate(pinner, uintptr(length289*(2*4)), 4) + for index, element := range slice287 { + base := unsafe.Add(result288, index*(2*4)) + utf8286 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8286) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8286))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length289) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result288))) + slice291 := ((element).Metadata).Examples + length293 := uint32(len(slice291)) + result292 := witRuntime.Allocate(pinner, uintptr(length293*(2*4)), 4) + for index, element := range slice291 { + base := unsafe.Add(result292, index*(2*4)) + utf8290 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8290) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8290))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length293) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result292))) + + 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)) + utf8294 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8294) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8294))) + + 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)) + utf8295 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8295) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8295))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length298) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result297))) + + 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)) + utf8299 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8299) + *(*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(utf8299))) + + 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)) + utf8300 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8300) + *(*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(utf8300))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result301 int32 + if (payload).Polymorphic { + result301 = 1 + } else { + result301 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result301) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8302 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8302) + *(*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(utf8302))) + + default: + panic("unreachable") + } + slice304 := ((element).Metadata).Aliases + length306 := uint32(len(slice304)) + result305 := witRuntime.Allocate(pinner, uintptr(length306*(2*4)), 4) + for index, element := range slice304 { + base := unsafe.Add(result305, index*(2*4)) + utf8303 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8303) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8303))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length306) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result305))) + slice308 := ((element).Metadata).Examples + length310 := uint32(len(slice308)) + result309 := witRuntime.Allocate(pinner, uintptr(length310*(2*4)), 4) + for index, element := range slice308 { + base := unsafe.Add(result309, index*(2*4)) + utf8307 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8307) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8307))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length310) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result309))) + + 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)) + utf8311 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8311) + *(*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(utf8311))) + + 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)) + utf8312 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8312) + *(*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(utf8312))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length315) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result314))) + slice318 := ((element).Schema).Defs + length320 := uint32(len(slice318)) + result319 := witRuntime.Allocate(pinner, uintptr(length320*(6*4)), 4) + for index, element := range slice318 { + base := unsafe.Add(result319, index*(6*4)) + utf8316 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8316) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8316))) + + 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)) + utf8317 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8317) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8317))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length320) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result319))) + *(*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)) + utf8321 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8321) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8321))) + + default: + panic("unreachable") + } + utf8322 := unsafe.Pointer(unsafe.StringData(((element).Constructor).Description)) + pinner.Pin(utf8322) + *(*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(utf8322))) + + 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)) + utf8323 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8323) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uintptr(uintptr(utf8323))) + + 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)) + slice336 := payload + length338 := uint32(len(slice336)) + result337 := witRuntime.Allocate(pinner, uintptr(length338*(8+16*4)), 4) + for index, element := range slice336 { + base := unsafe.Add(result337, index*(8+16*4)) + utf8324 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8324) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8324))) + + 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)) + utf8325 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8325) + *(*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(utf8325))) + + default: + panic("unreachable") + } + slice327 := ((element).Metadata).Aliases + length329 := uint32(len(slice327)) + result328 := witRuntime.Allocate(pinner, uintptr(length329*(2*4)), 4) + for index, element := range slice327 { + base := unsafe.Add(result328, index*(2*4)) + utf8326 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8326) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8326))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length329) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result328))) + slice331 := ((element).Metadata).Examples + length333 := uint32(len(slice331)) + result332 := witRuntime.Allocate(pinner, uintptr(length333*(2*4)), 4) + for index, element := range slice331 { + base := unsafe.Add(result332, index*(2*4)) + utf8330 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8330) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8330))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length333) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result332))) + + 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)) + utf8334 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8334) + *(*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(utf8334))) + + 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)) + utf8335 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8335) + *(*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(utf8335))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = uint32(length338) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = uint32(uintptr(uintptr(result337))) + + default: + panic("unreachable") + } + slice383 := (element).Methods + length385 := uint32(len(slice383)) + result384 := witRuntime.Allocate(pinner, uintptr(length385*(40+12*4)), 8) + for index, element := range slice383 { + base := unsafe.Add(result384, index*(40+12*4)) + utf8339 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8339) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8339))) + utf8340 := unsafe.Pointer(unsafe.StringData((element).Description)) + pinner.Pin(utf8340) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8340))) + slice363 := (element).HttpEndpoint + length365 := uint32(len(slice363)) + result364 := witRuntime.Allocate(pinner, uintptr(length365*(12*4)), 4) + for index, element := range slice363 { + base := unsafe.Add(result364, 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)) + utf8341 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8341) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8341))) + + default: + panic("unreachable") + } + slice345 := (element).PathSuffix + length347 := uint32(len(slice345)) + result346 := witRuntime.Allocate(pinner, uintptr(length347*(3*4)), 4) + for index, element := range slice345 { + base := unsafe.Add(result346, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8342 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8342) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8342))) + + 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)) + utf8343 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8343) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8343))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8344 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8344) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8344))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length347) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result346))) + slice350 := (element).HeaderVars + length352 := uint32(len(slice350)) + result351 := witRuntime.Allocate(pinner, uintptr(length352*(4*4)), 4) + for index, element := range slice350 { + base := unsafe.Add(result351, index*(4*4)) + utf8348 := unsafe.Pointer(unsafe.StringData((element).HeaderName)) + pinner.Pin(utf8348) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8348))) + utf8349 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8349) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8349))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length352) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result351))) + slice355 := (element).QueryVars + length357 := uint32(len(slice355)) + result356 := witRuntime.Allocate(pinner, uintptr(length357*(4*4)), 4) + for index, element := range slice355 { + base := unsafe.Add(result356, index*(4*4)) + utf8353 := unsafe.Pointer(unsafe.StringData((element).QueryParamName)) + pinner.Pin(utf8353) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8353))) + utf8354 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8354) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8354))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length357) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result356))) + + 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 result358 int32 + if (payload).Required { + result358 = 1 + } else { + result358 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result358) + + default: + panic("unreachable") + } + slice360 := ((element).CorsOptions).AllowedPatterns + length362 := uint32(len(slice360)) + result361 := witRuntime.Allocate(pinner, uintptr(length362*(2*4)), 4) + for index, element := range slice360 { + base := unsafe.Add(result361, index*(2*4)) + utf8359 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8359) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8359))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length362) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result361))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length365) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result364))) + + 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)) + utf8366 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8366) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8366))) + + 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)) + slice379 := payload + length381 := uint32(len(slice379)) + result380 := witRuntime.Allocate(pinner, uintptr(length381*(8+16*4)), 4) + for index, element := range slice379 { + base := unsafe.Add(result380, index*(8+16*4)) + utf8367 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8367) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8367))) + + 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)) + utf8368 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8368) + *(*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(utf8368))) + + default: + panic("unreachable") + } + slice370 := ((element).Metadata).Aliases + length372 := uint32(len(slice370)) + result371 := witRuntime.Allocate(pinner, uintptr(length372*(2*4)), 4) + for index, element := range slice370 { + base := unsafe.Add(result371, index*(2*4)) + utf8369 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8369) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8369))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length372) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result371))) + slice374 := ((element).Metadata).Examples + length376 := uint32(len(slice374)) + result375 := witRuntime.Allocate(pinner, uintptr(length376*(2*4)), 4) + for index, element := range slice374 { + base := unsafe.Add(result375, index*(2*4)) + utf8373 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8373) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8373))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length376) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result375))) + + 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)) + utf8377 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8377) + *(*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(utf8377))) + + 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)) + utf8378 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8378) + *(*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(utf8378))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length381) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result380))) + + 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 result382 int32 + if (payload).UsesPrincipal { + result382 = 1 + } else { + result382 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result382) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(length385) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(result384))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (25 * 4))) = uint32(length388) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (24 * 4))) = uint32(uintptr(uintptr(result387))) + *(*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)) + slice392 := (payload).PathPrefix + length394 := uint32(len(slice392)) + result393 := witRuntime.Allocate(pinner, uintptr(length394*(3*4)), 4) + for index, element := range slice392 { + base := unsafe.Add(result393, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8389 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8389) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8389))) + + 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)) + utf8390 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8390) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8390))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8391 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8391) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8391))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (29 * 4))) = uint32(length394) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (28 * 4))) = uint32(uintptr(uintptr(result393))) + + 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 result395 int32 + if (payload).Required { + result395 = 1 + } else { + result395 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (1 + 30*4))) = int8(result395) + + default: + panic("unreachable") + } + var result396 int32 + if (payload).PhantomAgent { + result396 = 1 + } else { + result396 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 + 30*4))) = int8(result396) + slice398 := ((payload).CorsOptions).AllowedPatterns + length400 := uint32(len(slice398)) + result399 := witRuntime.Allocate(pinner, uintptr(length400*(2*4)), 4) + for index, element := range slice398 { + base := unsafe.Add(result399, index*(2*4)) + utf8397 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8397) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8397))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (32 * 4))) = uint32(length400) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (31 * 4))) = uint32(uintptr(uintptr(result399))) + slice404 := (payload).WebhookSuffix + length406 := uint32(len(slice404)) + result405 := witRuntime.Allocate(pinner, uintptr(length406*(3*4)), 4) + for index, element := range slice404 { + base := unsafe.Add(result405, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8401 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8401) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8401))) + + 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)) + utf8402 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8402) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8402))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8403 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8403) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8403))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (34 * 4))) = uint32(length406) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (33 * 4))) = uint32(uintptr(uintptr(result405))) + + 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") + } + slice411 := (result).Config + length413 := uint32(len(slice411)) + result412 := witRuntime.Allocate(pinner, uintptr(length413*(4*4)), 4) + for index, element := range slice411 { + base := unsafe.Add(result412, index*(4*4)) + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32((element).Source)) + slice408 := (element).Path + length410 := uint32(len(slice408)) + result409 := witRuntime.Allocate(pinner, uintptr(length410*(2*4)), 4) + for index, element := range slice408 { + base := unsafe.Add(result409, index*(2*4)) + utf8407 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8407) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8407))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(length410) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(result409))) + *(*int32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = (element).ValueType + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (32 + 35*4))) = uint32(length413) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (32 + 34*4))) = uint32(uintptr(uintptr(result412))) + 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)) + slice414 := payload + length416 := uint32(len(slice414)) + result415 := witRuntime.Allocate(pinner, uintptr(length416*(32+36*4)), 8) + for index, element := range slice414 { + base := unsafe.Add(result415, 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))) + slice119 := ((element).Schema).TypeNodes + length121 := uint32(len(slice119)) + result120 := witRuntime.Allocate(pinner, uintptr(length121*(56+22*4)), 8) + for index, element := range slice119 { + base := unsafe.Add(result120, 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.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result107 int32 + if (payload).Polymorphic { + result107 = 1 + } else { + result107 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result107) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8108 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8108) + *(*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(utf8108))) + + default: + panic("unreachable") + } + slice110 := ((element).Metadata).Aliases + 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 + 12*4))) = uint32(length112) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result111))) + slice114 := ((element).Metadata).Examples + 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), (56 + 14*4))) = uint32(length116) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result115))) + + 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)) + utf8117 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8117) + *(*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(utf8117))) + + 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)) + utf8118 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8118) + *(*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(utf8118))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length121) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result120))) + slice124 := ((element).Schema).Defs + length126 := uint32(len(slice124)) + result125 := witRuntime.Allocate(pinner, uintptr(length126*(6*4)), 4) + for index, element := range slice124 { + base := unsafe.Add(result125, index*(6*4)) + utf8122 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8122) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8122))) + + 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)) + utf8123 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8123) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8123))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length126) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result125))) + *(*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)) + utf8127 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8127) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(utf8127))) + + default: + panic("unreachable") + } + utf8128 := unsafe.Pointer(unsafe.StringData(((element).Constructor).Description)) + pinner.Pin(utf8128) + *(*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(utf8128))) + + 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)) + utf8129 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8129) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8129))) + + 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)) + slice142 := payload + length144 := uint32(len(slice142)) + result143 := witRuntime.Allocate(pinner, uintptr(length144*(8+16*4)), 4) + for index, element := range slice142 { + base := unsafe.Add(result143, index*(8+16*4)) + utf8130 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8130) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8130))) + + 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)) + utf8131 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8131) + *(*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(utf8131))) + + default: + panic("unreachable") + } + slice133 := ((element).Metadata).Aliases + 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 + 6*4))) = uint32(length135) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result134))) + slice137 := ((element).Metadata).Examples + 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 + 8*4))) = uint32(length139) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result138))) + + 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)) + utf8140 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8140) + *(*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(utf8140))) + + 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)) + utf8141 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8141) + *(*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(utf8141))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(length144) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = uint32(uintptr(uintptr(result143))) + + default: + panic("unreachable") + } + slice189 := (element).Methods + length191 := uint32(len(slice189)) + result190 := witRuntime.Allocate(pinner, uintptr(length191*(40+12*4)), 8) + for index, element := range slice189 { + base := unsafe.Add(result190, index*(40+12*4)) + utf8145 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8145) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8145))) + utf8146 := unsafe.Pointer(unsafe.StringData((element).Description)) + pinner.Pin(utf8146) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8146))) + slice169 := (element).HttpEndpoint + length171 := uint32(len(slice169)) + result170 := witRuntime.Allocate(pinner, uintptr(length171*(12*4)), 4) + for index, element := range slice169 { + base := unsafe.Add(result170, 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)) + 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))) + + default: + panic("unreachable") + } + slice151 := (element).PathSuffix + length153 := uint32(len(slice151)) + result152 := witRuntime.Allocate(pinner, uintptr(length153*(3*4)), 4) + for index, element := range slice151 { + base := unsafe.Add(result152, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8148 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8148) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8148))) + + 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)) + 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))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8150 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8150) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8150))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length153) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result152))) + slice156 := (element).HeaderVars + length158 := uint32(len(slice156)) + result157 := witRuntime.Allocate(pinner, uintptr(length158*(4*4)), 4) + for index, element := range slice156 { + base := unsafe.Add(result157, index*(4*4)) + utf8154 := unsafe.Pointer(unsafe.StringData((element).HeaderName)) + pinner.Pin(utf8154) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8154))) + utf8155 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8155) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8155))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length158) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result157))) + slice161 := (element).QueryVars + length163 := uint32(len(slice161)) + result162 := witRuntime.Allocate(pinner, uintptr(length163*(4*4)), 4) + for index, element := range slice161 { + base := unsafe.Add(result162, index*(4*4)) + utf8159 := unsafe.Pointer(unsafe.StringData((element).QueryParamName)) + pinner.Pin(utf8159) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8159))) + utf8160 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8160) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8160))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length163) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result162))) + + 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 result164 int32 + if (payload).Required { + result164 = 1 + } else { + result164 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result164) + + default: + panic("unreachable") + } + slice166 := ((element).CorsOptions).AllowedPatterns + length168 := uint32(len(slice166)) + result167 := witRuntime.Allocate(pinner, uintptr(length168*(2*4)), 4) + for index, element := range slice166 { + base := unsafe.Add(result167, index*(2*4)) + utf8165 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8165) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8165))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length168) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result167))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length171) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result170))) + + 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)) + utf8172 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8172) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8172))) + + 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)) + slice185 := payload + length187 := uint32(len(slice185)) + result186 := witRuntime.Allocate(pinner, uintptr(length187*(8+16*4)), 4) + for index, element := range slice185 { + base := unsafe.Add(result186, index*(8+16*4)) + utf8173 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8173) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8173))) + + 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)) + utf8174 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8174) + *(*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(utf8174))) + + default: + panic("unreachable") + } + slice176 := ((element).Metadata).Aliases + length178 := uint32(len(slice176)) + result177 := witRuntime.Allocate(pinner, uintptr(length178*(2*4)), 4) + for index, element := range slice176 { + base := unsafe.Add(result177, index*(2*4)) + utf8175 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8175) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8175))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length178) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result177))) + slice180 := ((element).Metadata).Examples + length182 := uint32(len(slice180)) + result181 := witRuntime.Allocate(pinner, uintptr(length182*(2*4)), 4) + for index, element := range slice180 { + base := unsafe.Add(result181, index*(2*4)) + utf8179 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8179) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8179))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length182) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result181))) + + 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)) + utf8183 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8183) + *(*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(utf8183))) + + 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)) + utf8184 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8184) + *(*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(utf8184))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length187) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result186))) + + 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 result188 int32 + if (payload).UsesPrincipal { + result188 = 1 + } else { + result188 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result188) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (23 * 4))) = uint32(length191) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uintptr(uintptr(result190))) + slice386 := (element).Dependencies + length388 := uint32(len(slice386)) + result387 := witRuntime.Allocate(pinner, uintptr(length388*(23*4)), 4) + for index, element := range slice386 { + base := unsafe.Add(result387, index*(23*4)) + utf8192 := unsafe.Pointer(unsafe.StringData((element).TypeName)) + pinner.Pin(utf8192) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).TypeName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8192))) + + 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)) + utf8193 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8193) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8193))) + + default: + panic("unreachable") + } + slice313 := ((element).Schema).TypeNodes + length315 := uint32(len(slice313)) + result314 := witRuntime.Allocate(pinner, uintptr(length315*(56+22*4)), 8) + for index, element := range slice313 { + base := unsafe.Add(result314, 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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + utf8203 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8203) + *(*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(utf8203))) + + 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)) + slice216 := payload + length218 := uint32(len(slice216)) + result217 := witRuntime.Allocate(pinner, uintptr(length218*(17*4)), 4) + for index, element := range slice216 { + base := unsafe.Add(result217, index*(17*4)) + utf8204 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8204) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8204))) + *(*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)) + utf8205 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8205) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8205))) + + default: + panic("unreachable") + } + slice207 := ((element).Metadata).Aliases + length209 := uint32(len(slice207)) + result208 := witRuntime.Allocate(pinner, uintptr(length209*(2*4)), 4) + for index, element := range slice207 { + base := unsafe.Add(result208, index*(2*4)) + utf8206 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8206) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8206))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length209) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result208))) + slice211 := ((element).Metadata).Examples + 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), (9 * 4))) = uint32(length213) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result212))) + + 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)) + utf8214 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8214) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8214))) + + 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)) + utf8215 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8215) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf8215))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length218) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result217))) + + case golem_core_types.SchemaTypeBodyVariantType: + payload := (element).Body.VariantType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15)) + slice231 := payload + length233 := uint32(len(slice231)) + result232 := witRuntime.Allocate(pinner, uintptr(length233*(8+16*4)), 4) + for index, element := range slice231 { + base := unsafe.Add(result232, index*(8+16*4)) + utf8219 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8219) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8219))) + + 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)) + utf8220 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8220) + *(*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(utf8220))) + + default: + panic("unreachable") + } + slice222 := ((element).Metadata).Aliases + length224 := uint32(len(slice222)) + result223 := witRuntime.Allocate(pinner, uintptr(length224*(2*4)), 4) + for index, element := range slice222 { + base := unsafe.Add(result223, index*(2*4)) + utf8221 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8221) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8221))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length224) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result223))) + slice226 := ((element).Metadata).Examples + length228 := uint32(len(slice226)) + result227 := witRuntime.Allocate(pinner, uintptr(length228*(2*4)), 4) + for index, element := range slice226 { + base := unsafe.Add(result227, index*(2*4)) + utf8225 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8225) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8225))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length228) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result227))) + + 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)) + utf8229 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8229) + *(*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(utf8229))) + + 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)) + utf8230 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8230) + *(*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(utf8230))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length233) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result232))) + + case golem_core_types.SchemaTypeBodyEnumType: + payload := (element).Body.EnumType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16)) + slice235 := payload + length237 := uint32(len(slice235)) + result236 := witRuntime.Allocate(pinner, uintptr(length237*(2*4)), 4) + for index, element := range slice235 { + base := unsafe.Add(result236, index*(2*4)) + utf8234 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8234) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8234))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length237) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result236))) + + case golem_core_types.SchemaTypeBodyFlagsType: + payload := (element).Body.FlagsType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + slice239 := payload + length241 := uint32(len(slice239)) + result240 := witRuntime.Allocate(pinner, uintptr(length241*(2*4)), 4) + for index, element := range slice239 { + base := unsafe.Add(result240, index*(2*4)) + utf8238 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8238) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8238))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length241) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result240))) + + case golem_core_types.SchemaTypeBodyTupleType: + payload := (element).Body.TupleType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + slice242 := payload + length244 := uint32(len(slice242)) + result243 := witRuntime.Allocate(pinner, uintptr(length244*4), 4) + for index, element := range slice242 { + base := unsafe.Add(result243, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length244) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result243))) + + 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)) + slice246 := payload + length248 := uint32(len(slice246)) + result247 := witRuntime.Allocate(pinner, uintptr(length248*(2*4)), 4) + for index, element := range slice246 { + base := unsafe.Add(result247, index*(2*4)) + utf8245 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8245) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8245))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length248) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result247))) + + 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)) + utf8249 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8249) + *(*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(utf8249))) + + 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)) + slice251 := payload + 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), (8 + 2*4))) = uint32(length253) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result252))) + + 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)) + slice255 := payload + length257 := uint32(len(slice255)) + result256 := witRuntime.Allocate(pinner, uintptr(length257*(2*4)), 4) + for index, element := range slice255 { + base := unsafe.Add(result256, index*(2*4)) + utf8254 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8254) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8254))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length257) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result256))) + + 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)) + slice259 := payload + length261 := uint32(len(slice259)) + result260 := witRuntime.Allocate(pinner, uintptr(length261*(2*4)), 4) + for index, element := range slice259 { + base := unsafe.Add(result260, index*(2*4)) + utf8258 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8258) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8258))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length261) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result260))) + + 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)) + slice263 := payload + 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), (8 + 2*4))) = uint32(length265) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result264))) + + 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)) + slice267 := payload + 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), (8 + 5*4))) = uint32(length269) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result268))) + + 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)) + utf8270 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit)) + pinner.Pin(utf8270) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8270))) + slice272 := (payload).AllowedSuffixes + length274 := uint32(len(slice272)) + result273 := witRuntime.Allocate(pinner, uintptr(length274*(2*4)), 4) + for index, element := range slice272 { + base := unsafe.Add(result273, index*(2*4)) + utf8271 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8271) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8271))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length274) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result273))) + + 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 + utf8275 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8275) + *(*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(utf8275))) + + 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 + utf8276 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8276) + *(*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(utf8276))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaTypeBodyUnionType: + payload := (element).Body.UnionType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31)) + slice296 := (payload).Branches + length298 := uint32(len(slice296)) + result297 := witRuntime.Allocate(pinner, uintptr(length298*(23*4)), 4) + for index, element := range slice296 { + base := unsafe.Add(result297, index*(23*4)) + utf8277 := unsafe.Pointer(unsafe.StringData((element).Tag)) + pinner.Pin(utf8277) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8277))) + *(*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)) + 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.DiscriminatorRuleSuffix: + payload := (element).Discriminator.Suffix() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1)) + 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.DiscriminatorRuleContains: + payload := (element).Discriminator.Contains() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2)) + 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.DiscriminatorRuleRegex: + payload := (element).Discriminator.Regex() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3)) + utf8281 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8281) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8281))) + + case golem_core_types.DiscriminatorRuleFieldEquals: + payload := (element).Discriminator.FieldEquals() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4)) + utf8282 := unsafe.Pointer(unsafe.StringData((payload).FieldName)) + pinner.Pin(utf8282) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8282))) + + 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)) + utf8283 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8283) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8283))) + + default: + panic("unreachable") + } + + case golem_core_types.DiscriminatorRuleFieldAbsent: + payload := (element).Discriminator.FieldAbsent() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5)) + utf8284 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8284) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8284))) + + 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)) + utf8285 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8285) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8285))) + + default: + panic("unreachable") + } + slice287 := ((element).Metadata).Aliases + length289 := uint32(len(slice287)) + result288 := witRuntime.Allocate(pinner, uintptr(length289*(2*4)), 4) + for index, element := range slice287 { + base := unsafe.Add(result288, index*(2*4)) + utf8286 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8286) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8286))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length289) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result288))) + slice291 := ((element).Metadata).Examples + length293 := uint32(len(slice291)) + result292 := witRuntime.Allocate(pinner, uintptr(length293*(2*4)), 4) + for index, element := range slice291 { + base := unsafe.Add(result292, index*(2*4)) + utf8290 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8290) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8290))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length293) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result292))) + + 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)) + utf8294 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8294) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8294))) + + 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)) + utf8295 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8295) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8295))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length298) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result297))) + + 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)) + utf8299 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8299) + *(*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(utf8299))) + + 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)) + utf8300 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8300) + *(*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(utf8300))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result301 int32 + if (payload).Polymorphic { + result301 = 1 + } else { + result301 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result301) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8302 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8302) + *(*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(utf8302))) + + default: + panic("unreachable") + } + slice304 := ((element).Metadata).Aliases + length306 := uint32(len(slice304)) + result305 := witRuntime.Allocate(pinner, uintptr(length306*(2*4)), 4) + for index, element := range slice304 { + base := unsafe.Add(result305, index*(2*4)) + utf8303 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8303) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8303))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length306) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result305))) + slice308 := ((element).Metadata).Examples + length310 := uint32(len(slice308)) + result309 := witRuntime.Allocate(pinner, uintptr(length310*(2*4)), 4) + for index, element := range slice308 { + base := unsafe.Add(result309, index*(2*4)) + utf8307 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8307) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8307))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length310) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result309))) + + 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)) + utf8311 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8311) + *(*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(utf8311))) + + 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)) + utf8312 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8312) + *(*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(utf8312))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length315) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result314))) + slice318 := ((element).Schema).Defs + length320 := uint32(len(slice318)) + result319 := witRuntime.Allocate(pinner, uintptr(length320*(6*4)), 4) + for index, element := range slice318 { + base := unsafe.Add(result319, index*(6*4)) + utf8316 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8316) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8316))) + + 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)) + utf8317 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8317) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8317))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length320) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result319))) + *(*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)) + utf8321 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8321) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8321))) + + default: + panic("unreachable") + } + utf8322 := unsafe.Pointer(unsafe.StringData(((element).Constructor).Description)) + pinner.Pin(utf8322) + *(*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(utf8322))) + + 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)) + utf8323 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8323) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uintptr(uintptr(utf8323))) + + 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)) + slice336 := payload + length338 := uint32(len(slice336)) + result337 := witRuntime.Allocate(pinner, uintptr(length338*(8+16*4)), 4) + for index, element := range slice336 { + base := unsafe.Add(result337, index*(8+16*4)) + utf8324 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8324) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8324))) + + 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)) + utf8325 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8325) + *(*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(utf8325))) + + default: + panic("unreachable") + } + slice327 := ((element).Metadata).Aliases + length329 := uint32(len(slice327)) + result328 := witRuntime.Allocate(pinner, uintptr(length329*(2*4)), 4) + for index, element := range slice327 { + base := unsafe.Add(result328, index*(2*4)) + utf8326 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8326) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8326))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length329) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result328))) + slice331 := ((element).Metadata).Examples + length333 := uint32(len(slice331)) + result332 := witRuntime.Allocate(pinner, uintptr(length333*(2*4)), 4) + for index, element := range slice331 { + base := unsafe.Add(result332, index*(2*4)) + utf8330 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8330) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8330))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length333) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result332))) + + 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)) + utf8334 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8334) + *(*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(utf8334))) + + 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)) + utf8335 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8335) + *(*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(utf8335))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (20 * 4))) = uint32(length338) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (19 * 4))) = uint32(uintptr(uintptr(result337))) + + default: + panic("unreachable") + } + slice383 := (element).Methods + length385 := uint32(len(slice383)) + result384 := witRuntime.Allocate(pinner, uintptr(length385*(40+12*4)), 8) + for index, element := range slice383 { + base := unsafe.Add(result384, index*(40+12*4)) + utf8339 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8339) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8339))) + utf8340 := unsafe.Pointer(unsafe.StringData((element).Description)) + pinner.Pin(utf8340) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).Description))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8340))) + slice363 := (element).HttpEndpoint + length365 := uint32(len(slice363)) + result364 := witRuntime.Allocate(pinner, uintptr(length365*(12*4)), 4) + for index, element := range slice363 { + base := unsafe.Add(result364, 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)) + utf8341 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8341) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8341))) + + default: + panic("unreachable") + } + slice345 := (element).PathSuffix + length347 := uint32(len(slice345)) + result346 := witRuntime.Allocate(pinner, uintptr(length347*(3*4)), 4) + for index, element := range slice345 { + base := unsafe.Add(result346, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8342 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8342) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8342))) + + 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)) + utf8343 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8343) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8343))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8344 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8344) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8344))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(length347) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(result346))) + slice350 := (element).HeaderVars + length352 := uint32(len(slice350)) + result351 := witRuntime.Allocate(pinner, uintptr(length352*(4*4)), 4) + for index, element := range slice350 { + base := unsafe.Add(result351, index*(4*4)) + utf8348 := unsafe.Pointer(unsafe.StringData((element).HeaderName)) + pinner.Pin(utf8348) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).HeaderName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8348))) + utf8349 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8349) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8349))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(length352) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uintptr(uintptr(result351))) + slice355 := (element).QueryVars + length357 := uint32(len(slice355)) + result356 := witRuntime.Allocate(pinner, uintptr(length357*(4*4)), 4) + for index, element := range slice355 { + base := unsafe.Add(result356, index*(4*4)) + utf8353 := unsafe.Pointer(unsafe.StringData((element).QueryParamName)) + pinner.Pin(utf8353) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).QueryParamName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8353))) + utf8354 := unsafe.Pointer(unsafe.StringData((element).VariableName)) + pinner.Pin(utf8354) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uint32(len((element).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uintptr(uintptr(utf8354))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(length357) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(result356))) + + 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 result358 int32 + if (payload).Required { + result358 = 1 + } else { + result358 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 9*4))) = int8(result358) + + default: + panic("unreachable") + } + slice360 := ((element).CorsOptions).AllowedPatterns + length362 := uint32(len(slice360)) + result361 := witRuntime.Allocate(pinner, uintptr(length362*(2*4)), 4) + for index, element := range slice360 { + base := unsafe.Add(result361, index*(2*4)) + utf8359 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8359) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8359))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length362) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result361))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(length365) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(result364))) + + 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)) + utf8366 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8366) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8366))) + + 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)) + slice379 := payload + length381 := uint32(len(slice379)) + result380 := witRuntime.Allocate(pinner, uintptr(length381*(8+16*4)), 4) + for index, element := range slice379 { + base := unsafe.Add(result380, index*(8+16*4)) + utf8367 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8367) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8367))) + + 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)) + utf8368 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8368) + *(*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(utf8368))) + + default: + panic("unreachable") + } + slice370 := ((element).Metadata).Aliases + length372 := uint32(len(slice370)) + result371 := witRuntime.Allocate(pinner, uintptr(length372*(2*4)), 4) + for index, element := range slice370 { + base := unsafe.Add(result371, index*(2*4)) + utf8369 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8369) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8369))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length372) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result371))) + slice374 := ((element).Metadata).Examples + length376 := uint32(len(slice374)) + result375 := witRuntime.Allocate(pinner, uintptr(length376*(2*4)), 4) + for index, element := range slice374 { + base := unsafe.Add(result375, index*(2*4)) + utf8373 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8373) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8373))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length376) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result375))) + + 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)) + utf8377 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8377) + *(*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(utf8377))) + + 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)) + utf8378 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8378) + *(*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(utf8378))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(length381) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(result380))) + + 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 result382 int32 + if (payload).UsesPrincipal { + result382 = 1 + } else { + result382 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (32 + 12*4))) = int8(result382) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(length385) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(result384))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (25 * 4))) = uint32(length388) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (24 * 4))) = uint32(uintptr(uintptr(result387))) + *(*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)) + slice392 := (payload).PathPrefix + length394 := uint32(len(slice392)) + result393 := witRuntime.Allocate(pinner, uintptr(length394*(3*4)), 4) + for index, element := range slice392 { + base := unsafe.Add(result393, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8389 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8389) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8389))) + + 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)) + utf8390 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8390) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8390))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8391 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8391) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8391))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (29 * 4))) = uint32(length394) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (28 * 4))) = uint32(uintptr(uintptr(result393))) + + 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 result395 int32 + if (payload).Required { + result395 = 1 + } else { + result395 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (1 + 30*4))) = int8(result395) + + default: + panic("unreachable") + } + var result396 int32 + if (payload).PhantomAgent { + result396 = 1 + } else { + result396 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), (2 + 30*4))) = int8(result396) + slice398 := ((payload).CorsOptions).AllowedPatterns + length400 := uint32(len(slice398)) + result399 := witRuntime.Allocate(pinner, uintptr(length400*(2*4)), 4) + for index, element := range slice398 { + base := unsafe.Add(result399, index*(2*4)) + utf8397 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8397) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8397))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 * 4))) = uint32(length400) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (31 * 4))) = uint32(uintptr(uintptr(result399))) + slice404 := (payload).WebhookSuffix + length406 := uint32(len(slice404)) + result405 := witRuntime.Allocate(pinner, uintptr(length406*(3*4)), 4) + for index, element := range slice404 { + base := unsafe.Add(result405, index*(3*4)) + + switch element.Tag() { + case golem_agent_common.PathSegmentLiteral: + payload := element.Literal() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(0)) + utf8401 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8401) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8401))) + + 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)) + utf8402 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8402) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8402))) + + case golem_agent_common.PathSegmentRemainingPathVariable: + payload := element.RemainingPathVariable() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(3)) + utf8403 := unsafe.Pointer(unsafe.StringData((payload).VariableName)) + pinner.Pin(utf8403) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(uint32(len((payload).VariableName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(utf8403))) + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (34 * 4))) = uint32(length406) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (33 * 4))) = uint32(uintptr(uintptr(result405))) + + 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") + } + slice411 := (element).Config + length413 := uint32(len(slice411)) + result412 := witRuntime.Allocate(pinner, uintptr(length413*(4*4)), 4) + for index, element := range slice411 { + base := unsafe.Add(result412, index*(4*4)) + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32((element).Source)) + slice408 := (element).Path + length410 := uint32(len(slice408)) + result409 := witRuntime.Allocate(pinner, uintptr(length410*(2*4)), 4) + for index, element := range slice408 { + base := unsafe.Add(result409, index*(2*4)) + utf8407 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8407) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8407))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = uint32(length410) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uintptr(uintptr(result409))) + *(*int32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = (element).ValueType + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 35*4))) = uint32(length413) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (32 + 34*4))) = uint32(uintptr(uintptr(result412))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(length416) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = uint32(uintptr(uintptr(result415))) + + 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)) + 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.AgentErrorInvalidMethod: + payload := payload.InvalidMethod() + *(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(1)) + 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.AgentErrorInvalidType: + payload := payload.InvalidType() + *(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(2)) + utf8419 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8419) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(utf8419))) + + case golem_agent_common.AgentErrorInvalidAgentId: + payload := payload.InvalidAgentId() + *(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(3)) + utf8420 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8420) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(utf8420))) + + case golem_agent_common.AgentErrorCustomError: + payload := payload.CustomError() + *(*int8)(unsafe.Add(unsafe.Pointer(exportReturnArea), 4)) = int8(int32(4)) + slice540 := ((payload).Graph).TypeNodes + length542 := uint32(len(slice540)) + result541 := witRuntime.Allocate(pinner, uintptr(length542*(56+22*4)), 8) + for index, element := range slice540 { + base := unsafe.Add(result541, 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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + 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.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)) + utf8429 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8429) + *(*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(utf8429))) + + 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)) + utf8430 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8430) + *(*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(utf8430))) + + 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)) + slice443 := payload + length445 := uint32(len(slice443)) + result444 := witRuntime.Allocate(pinner, uintptr(length445*(17*4)), 4) + for index, element := range slice443 { + base := unsafe.Add(result444, index*(17*4)) + utf8431 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8431) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8431))) + *(*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)) + utf8432 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8432) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8432))) + + default: + panic("unreachable") + } + slice434 := ((element).Metadata).Aliases + length436 := uint32(len(slice434)) + result435 := witRuntime.Allocate(pinner, uintptr(length436*(2*4)), 4) + for index, element := range slice434 { + base := unsafe.Add(result435, index*(2*4)) + utf8433 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8433) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8433))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(length436) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (6 * 4))) = uint32(uintptr(uintptr(result435))) + slice438 := ((element).Metadata).Examples + length440 := uint32(len(slice438)) + result439 := witRuntime.Allocate(pinner, uintptr(length440*(2*4)), 4) + for index, element := range slice438 { + base := unsafe.Add(result439, index*(2*4)) + utf8437 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8437) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8437))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (9 * 4))) = uint32(length440) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uintptr(uintptr(result439))) + + 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)) + utf8441 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8441) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uintptr(uintptr(utf8441))) + + 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)) + utf8442 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8442) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (16 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(uintptr(uintptr(utf8442))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length445) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result444))) + + case golem_core_types.SchemaTypeBodyVariantType: + payload := (element).Body.VariantType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(15)) + slice458 := payload + length460 := uint32(len(slice458)) + result459 := witRuntime.Allocate(pinner, uintptr(length460*(8+16*4)), 4) + for index, element := range slice458 { + base := unsafe.Add(result459, index*(8+16*4)) + utf8446 := unsafe.Pointer(unsafe.StringData((element).Name)) + pinner.Pin(utf8446) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Name))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8446))) + + 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)) + utf8447 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8447) + *(*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(utf8447))) + + default: + panic("unreachable") + } + slice449 := ((element).Metadata).Aliases + length451 := uint32(len(slice449)) + result450 := witRuntime.Allocate(pinner, uintptr(length451*(2*4)), 4) + for index, element := range slice449 { + base := unsafe.Add(result450, index*(2*4)) + utf8448 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8448) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8448))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length451) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result450))) + slice453 := ((element).Metadata).Examples + length455 := uint32(len(slice453)) + result454 := witRuntime.Allocate(pinner, uintptr(length455*(2*4)), 4) + for index, element := range slice453 { + base := unsafe.Add(result454, index*(2*4)) + utf8452 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8452) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8452))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 8*4))) = uint32(length455) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 7*4))) = uint32(uintptr(uintptr(result454))) + + 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)) + utf8456 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8456) + *(*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(utf8456))) + + 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)) + utf8457 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8457) + *(*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(utf8457))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length460) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result459))) + + case golem_core_types.SchemaTypeBodyEnumType: + payload := (element).Body.EnumType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(16)) + slice462 := payload + length464 := uint32(len(slice462)) + result463 := witRuntime.Allocate(pinner, uintptr(length464*(2*4)), 4) + for index, element := range slice462 { + base := unsafe.Add(result463, index*(2*4)) + utf8461 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8461) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8461))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length464) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result463))) + + case golem_core_types.SchemaTypeBodyFlagsType: + payload := (element).Body.FlagsType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + slice466 := payload + length468 := uint32(len(slice466)) + result467 := witRuntime.Allocate(pinner, uintptr(length468*(2*4)), 4) + for index, element := range slice466 { + base := unsafe.Add(result467, index*(2*4)) + utf8465 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8465) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8465))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length468) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result467))) + + case golem_core_types.SchemaTypeBodyTupleType: + payload := (element).Body.TupleType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + slice469 := payload + length471 := uint32(len(slice469)) + result470 := witRuntime.Allocate(pinner, uintptr(length471*4), 4) + for index, element := range slice469 { + base := unsafe.Add(result470, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length471) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result470))) + + 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)) + slice473 := payload + length475 := uint32(len(slice473)) + result474 := witRuntime.Allocate(pinner, uintptr(length475*(2*4)), 4) + for index, element := range slice473 { + base := unsafe.Add(result474, index*(2*4)) + utf8472 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8472) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8472))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length475) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result474))) + + 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)) + utf8476 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8476) + *(*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(utf8476))) + + 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)) + slice478 := payload + length480 := uint32(len(slice478)) + result479 := witRuntime.Allocate(pinner, uintptr(length480*(2*4)), 4) + for index, element := range slice478 { + base := unsafe.Add(result479, index*(2*4)) + utf8477 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8477) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8477))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length480) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result479))) + + 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)) + slice482 := payload + length484 := uint32(len(slice482)) + result483 := witRuntime.Allocate(pinner, uintptr(length484*(2*4)), 4) + for index, element := range slice482 { + base := unsafe.Add(result483, index*(2*4)) + utf8481 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8481) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8481))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length484) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result483))) + + 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)) + slice486 := payload + length488 := uint32(len(slice486)) + result487 := witRuntime.Allocate(pinner, uintptr(length488*(2*4)), 4) + for index, element := range slice486 { + base := unsafe.Add(result487, index*(2*4)) + utf8485 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8485) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8485))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 6*4))) = uint32(length488) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(uintptr(uintptr(result487))) + + 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)) + slice490 := payload + length492 := uint32(len(slice490)) + result491 := witRuntime.Allocate(pinner, uintptr(length492*(2*4)), 4) + for index, element := range slice490 { + base := unsafe.Add(result491, index*(2*4)) + utf8489 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8489) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8489))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(length492) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uintptr(uintptr(result491))) + + 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)) + slice494 := payload + length496 := uint32(len(slice494)) + result495 := witRuntime.Allocate(pinner, uintptr(length496*(2*4)), 4) + for index, element := range slice494 { + base := unsafe.Add(result495, index*(2*4)) + utf8493 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8493) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8493))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 5*4))) = uint32(length496) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 4*4))) = uint32(uintptr(uintptr(result495))) + + 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)) + utf8497 := unsafe.Pointer(unsafe.StringData((payload).BaseUnit)) + pinner.Pin(utf8497) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).BaseUnit))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8497))) + slice499 := (payload).AllowedSuffixes + length501 := uint32(len(slice499)) + result500 := witRuntime.Allocate(pinner, uintptr(length501*(2*4)), 4) + for index, element := range slice499 { + base := unsafe.Add(result500, index*(2*4)) + utf8498 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8498) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8498))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 3*4))) = uint32(length501) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 2*4))) = uint32(uintptr(uintptr(result500))) + + 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 + utf8502 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8502) + *(*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(utf8502))) + + 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 + utf8503 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8503) + *(*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(utf8503))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaTypeBodyUnionType: + payload := (element).Body.UnionType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(31)) + slice523 := (payload).Branches + length525 := uint32(len(slice523)) + result524 := witRuntime.Allocate(pinner, uintptr(length525*(23*4)), 4) + for index, element := range slice523 { + base := unsafe.Add(result524, index*(23*4)) + utf8504 := unsafe.Pointer(unsafe.StringData((element).Tag)) + pinner.Pin(utf8504) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8504))) + *(*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)) + 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.DiscriminatorRuleSuffix: + payload := (element).Discriminator.Suffix() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(1)) + 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.DiscriminatorRuleContains: + payload := (element).Discriminator.Contains() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(2)) + utf8507 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8507) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8507))) + + case golem_core_types.DiscriminatorRuleRegex: + payload := (element).Discriminator.Regex() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(3)) + utf8508 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8508) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8508))) + + case golem_core_types.DiscriminatorRuleFieldEquals: + payload := (element).Discriminator.FieldEquals() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(4)) + utf8509 := unsafe.Pointer(unsafe.StringData((payload).FieldName)) + pinner.Pin(utf8509) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len((payload).FieldName))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8509))) + + 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)) + utf8510 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8510) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (7 * 4))) = uint32(uintptr(uintptr(utf8510))) + + default: + panic("unreachable") + } + + case golem_core_types.DiscriminatorRuleFieldAbsent: + payload := (element).Discriminator.FieldAbsent() + *(*int8)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = int8(int32(5)) + utf8511 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8511) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uintptr(uintptr(utf8511))) + + 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)) + utf8512 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8512) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (11 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (10 * 4))) = uint32(uintptr(uintptr(utf8512))) + + default: + panic("unreachable") + } + slice514 := ((element).Metadata).Aliases + length516 := uint32(len(slice514)) + result515 := witRuntime.Allocate(pinner, uintptr(length516*(2*4)), 4) + for index, element := range slice514 { + base := unsafe.Add(result515, index*(2*4)) + utf8513 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8513) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8513))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (13 * 4))) = uint32(length516) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (12 * 4))) = uint32(uintptr(uintptr(result515))) + slice518 := ((element).Metadata).Examples + length520 := uint32(len(slice518)) + result519 := witRuntime.Allocate(pinner, uintptr(length520*(2*4)), 4) + for index, element := range slice518 { + base := unsafe.Add(result519, index*(2*4)) + utf8517 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8517) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8517))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (15 * 4))) = uint32(length520) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (14 * 4))) = uint32(uintptr(uintptr(result519))) + + 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)) + utf8521 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8521) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (18 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (17 * 4))) = uint32(uintptr(uintptr(utf8521))) + + 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)) + utf8522 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8522) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (22 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (21 * 4))) = uint32(uintptr(uintptr(utf8522))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length525) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result524))) + + 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)) + utf8526 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8526) + *(*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(utf8526))) + + 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)) + utf8527 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8527) + *(*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(utf8527))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaTypeBodyPermissionCardType: + payload := (element).Body.PermissionCardType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(34)) + var result528 int32 + if (payload).Polymorphic { + result528 = 1 + } else { + result528 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result528) + + case golem_core_types.SchemaTypeBodyFutureType: + payload := (element).Body.FutureType() + *(*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") + } + + case golem_core_types.SchemaTypeBodyStreamType: + payload := (element).Body.StreamType() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(36)) + + 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)) + utf8529 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8529) + *(*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(utf8529))) + + default: + panic("unreachable") + } + slice531 := ((element).Metadata).Aliases + length533 := uint32(len(slice531)) + result532 := witRuntime.Allocate(pinner, uintptr(length533*(2*4)), 4) + for index, element := range slice531 { + base := unsafe.Add(result532, index*(2*4)) + utf8530 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8530) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8530))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 12*4))) = uint32(length533) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 11*4))) = uint32(uintptr(uintptr(result532))) + slice535 := ((element).Metadata).Examples + length537 := uint32(len(slice535)) + result536 := witRuntime.Allocate(pinner, uintptr(length537*(2*4)), 4) + for index, element := range slice535 { + base := unsafe.Add(result536, index*(2*4)) + utf8534 := unsafe.Pointer(unsafe.StringData(element)) + pinner.Pin(utf8534) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len(element))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8534))) + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 14*4))) = uint32(length537) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (56 + 13*4))) = uint32(uintptr(uintptr(result536))) + + 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)) + utf8538 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8538) + *(*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(utf8538))) + + 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)) + utf8539 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8539) + *(*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(utf8539))) + + default: + panic("unreachable") + } + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (3 * 4))) = uint32(length542) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (2 * 4))) = uint32(uintptr(uintptr(result541))) + slice545 := ((payload).Graph).Defs + length547 := uint32(len(slice545)) + result546 := witRuntime.Allocate(pinner, uintptr(length547*(6*4)), 4) + for index, element := range slice545 { + base := unsafe.Add(result546, index*(6*4)) + utf8543 := unsafe.Pointer(unsafe.StringData((element).Id)) + pinner.Pin(utf8543) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Id))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf8543))) + + 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)) + utf8544 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8544) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (4 * 4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (3 * 4))) = uint32(uintptr(uintptr(utf8544))) + + default: + panic("unreachable") + } + *(*int32)(unsafe.Add(unsafe.Pointer(base), (5 * 4))) = (element).Body + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (5 * 4))) = uint32(length547) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (4 * 4))) = uint32(uintptr(uintptr(result546))) + *(*int32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (6 * 4))) = ((payload).Graph).Root + slice576 := ((payload).Value).ValueNodes + length578 := uint32(len(slice576)) + result577 := witRuntime.Allocate(pinner, uintptr(length578*(16+4*4)), 8) + for index, element := range slice576 { + base := unsafe.Add(result577, 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 result548 int32 + if payload { + result548 = 1 + } else { + result548 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 8)) = int8(result548) + + 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)) + utf8549 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8549) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8549))) + + case golem_core_types.SchemaValueNodeRecordValue: + payload := element.RecordValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(13)) + slice550 := payload + length552 := uint32(len(slice550)) + result551 := witRuntime.Allocate(pinner, uintptr(length552*4), 4) + for index, element := range slice550 { + base := unsafe.Add(result551, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(length552) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result551))) + + 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)) + slice554 := payload + length556 := uint32(len(slice554)) + result555 := witRuntime.Allocate(pinner, uintptr(length556*1), 1) + for index, element := range slice554 { + base := unsafe.Add(result555, index*1) + var result553 int32 + if element { + result553 = 1 + } else { + result553 = 0 + } + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(result553) + + } + + *(*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.SchemaValueNodeTupleValue: + payload := element.TupleValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(17)) + 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.SchemaValueNodeListValue: + payload := element.ListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(18)) + 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.SchemaValueNodeFixedListValue: + payload := element.FixedListValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(19)) + slice563 := payload + length565 := uint32(len(slice563)) + result564 := witRuntime.Allocate(pinner, uintptr(length565*4), 4) + for index, element := range slice563 { + base := unsafe.Add(result564, index*4) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 0)) = element + + } + + *(*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.SchemaValueNodeMapValue: + payload := element.MapValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(20)) + slice566 := payload + length568 := uint32(len(slice566)) + result567 := witRuntime.Allocate(pinner, uintptr(length568*8), 4) + for index, element := range slice566 { + base := unsafe.Add(result567, 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(length568) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(result567))) + + 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)) + utf8569 := unsafe.Pointer(unsafe.StringData((payload).Text)) + pinner.Pin(utf8569) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Text))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8569))) + + 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)) + utf8570 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8570) + *(*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(utf8570))) + + 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)) + utf8571 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8571) + *(*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(utf8571))) + + default: + panic("unreachable") + } + + case golem_core_types.SchemaValueNodePathValue: + payload := element.PathValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(25)) + utf8572 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8572) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8572))) + + case golem_core_types.SchemaValueNodeUrlValue: + payload := element.UrlValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(26)) + utf8573 := unsafe.Pointer(unsafe.StringData(payload)) + pinner.Pin(utf8573) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len(payload))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8573))) + + 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 + utf8574 := unsafe.Pointer(unsafe.StringData((payload).Unit)) + pinner.Pin(utf8574) + *(*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(utf8574))) + + case golem_core_types.SchemaValueNodeUnionValue: + payload := element.UnionValue() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(30)) + utf8575 := unsafe.Pointer(unsafe.StringData((payload).Tag)) + pinner.Pin(utf8575) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), (8 + 1*4))) = uint32(uint32(len((payload).Tag))) + *(*uint32)(unsafe.Add(unsafe.Pointer(base), 8)) = uint32(uintptr(uintptr(utf8575))) + *(*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() + + case golem_core_types.SchemaValueNodePermissionCardHandle: + payload := element.PermissionCardHandle() + *(*int8)(unsafe.Add(unsafe.Pointer(base), 0)) = int8(int32(33)) + *(*int32)(unsafe.Add(unsafe.Pointer(base), 8)) = (payload).TakeHandle() + + default: + panic("unreachable") + } + + } + + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (8 * 4))) = uint32(length578) + *(*uint32)(unsafe.Add(unsafe.Pointer(exportReturnArea), (7 * 4))) = uint32(uintptr(uintptr(result577))) + *(*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..24c966a880 --- /dev/null +++ b/sdks/go/golem/keyvalue/keyvalue.go @@ -0,0 +1,228 @@ +// 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 JSON codec behind Store. +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..9302c826d8 --- /dev/null +++ b/sdks/go/golem/log/log.go @@ -0,0 +1,189 @@ +// 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. +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..f67ce5e66b --- /dev/null +++ b/sdks/go/golem/misuse_test.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 ( + "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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + m := DefineMethod[Id, Unit, Unit]("m", Desc("a"), Desc("b")) + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, 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 } + withDefs(t, func(d *definitions) { + defineAgentInto[SharedID, NoConfig](d, Spec{Name: "A1"}) + defineAgentInto[SharedID, NoConfig](d, Spec{Name: "A2"}) + mustDefErr(t, d, "already used by agent") + }) +} + +func TestMisuseDuplicateAgentName(t *testing.T) { + type Id1 struct{ A string } + type Id2 struct{ B string } + withDefs(t, func(d *definitions) { + defineAgentInto[Id1, NoConfig](d, Spec{Name: "Dup"}) + defineAgentInto[Id2, NoConfig](d, Spec{Name: "Dup"}) + mustDefErr(t, d, "already defined") + }) +} + +func TestMisuseNonStructId(t *testing.T) { + withDefs(t, func(d *definitions) { + defineAgentInto[int, NoConfig](d, Spec{Name: "A"}) + 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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + implementInto[Id, St, NoConfig](d, def, nil, true) + mustDefErr(t, d, "non-nil init") + }) +} + +func TestMisuseNilHandler(t *testing.T) { + type Id struct{ Name string } + type St struct{} + withDefs(t, func(d *definitions) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, DefineMethod[Id, Unit, Unit]("m"), (func(*Context[St], Unit) Unit)(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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, 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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + m := DefineMethod[Id, Unit, Unit]("m") + h := func(*Context[St], Unit) Unit { return Unit{} } + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, m, h) + Handle(impl, m, h) + mustDefErr(t, d, "already implemented") + }) +} + +// --- incomplete agents (discover guard) ------------------------------------- + +func TestMisuseUnimplementedOrMethodless(t *testing.T) { + type Id struct{ Name string } + type St struct{} + withDefs(t, func(d *definitions) { + defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) // defined, never implemented + mustDefErr(t, d, "never implemented") + }) + withDefs(t, func(d *definitions) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "B"}) + implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) // no Handle + mustDefErr(t, d, "has no methods") + }) +} + +// --- 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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A", HTTP: &Mount{Path: "/a/{name}"}}) + m1 := DefineMethod[Id, In, Unit]("m1", HTTP(GET("/dup/{x}"))) + m2 := DefineMethod[Id, In, Unit]("m2", HTTP(GET("/dup/{x}"))) + h := func(*Context[St], In) Unit { return Unit{} } + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, m1, h) + Handle(impl, m2, h) + 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..955537a4d2 --- /dev/null +++ b/sdks/go/golem/named.go @@ -0,0 +1,58 @@ +// 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. +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..179081325f --- /dev/null +++ b/sdks/go/golem/promise.go @@ -0,0 +1,184 @@ +// 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, so an external +// completer (a webhook, a curl, a human) can produce them. 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 { + res := host.CreateWebhook(p.id.toWit()) + if res.IsErr() { + panic(webhookErrorToGo(res.Err())) + } + return res.Ok() +} + +func webhookErrorToGo(e host.WebhookError) error { + switch e.Tag() { + case host.WebhookErrorPermissionDenied: + return fmt.Errorf("golem: webhook: permission denied") + case host.WebhookErrorInternalError: + return fmt.Errorf("golem: webhook: internal error: %s", e.InternalError()) + default: + return fmt.Errorf("golem: webhook: error (tag %d)", e.Tag()) + } +} + +// 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..a662076510 --- /dev/null +++ b/sdks/go/golem/rdbms/postgres/postgres.go @@ -0,0 +1,1606 @@ +// 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. +// +// Constructing a DbValue is side-effect free; a bad element (in a recursive +// [Array]/[Composite]/[Domain]/[CustomRange]) surfaces as a normal parameter +// error when the query runs, not at construction. +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 into a flat part (decodeFlat, every non-recursive family) and +// the host-backed recursive part (decodeLazy, which calls LazyDbValue.Get/Drop). + +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. + +// 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..8ddbab4fb6 --- /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 +// postgres and mysql drivers. 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. +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..9403bcd3f1 --- /dev/null +++ b/sdks/go/golem/readonly_test.go @@ -0,0 +1,102 @@ +// 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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + handle := func(name string, opts ...MethodOpt) { + Handle(impl, DefineMethod[Id, Unit, Unit](name, opts...), h) + } + handle("rw") // read-write + handle("ro", ReadOnly()) // default => until-write + handle("nc", ReadOnly(NoCache())) + handle("uw", ReadOnly(CacheUntilWrite())) + handle("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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A", Mode: c.mode}) + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, 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..b7fc8b631a --- /dev/null +++ b/sdks/go/golem/registry.go @@ -0,0 +1,423 @@ +// 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 declares a config-less agent and returns its state-free +// [AgentDefinition]. Put it in a package-level var in the agent's DEFINITION +// package; other agents import that package to call the agent. The behaviour and +// the private state are attached separately with [Implement] — typically from a +// different (implementation) package, so agents can call one another without a Go +// import cycle. +// +// To attach config, declare the agent with [DefineConfiguredAgent]. +func DefineAgent[Id any](spec Spec) *AgentDefinition[Id, NoConfig] { + return defineAgentInto[Id, NoConfig](defs, spec) +} + +// DefineConfiguredAgent declares an agent with config type Cfg and returns its +// state-free [AgentDefinition]. Cfg rides on the definition, so a method reads +// config with [Config] and the constructor reads it with [InitContext.Config]. +// Attach the behaviour with [ImplementConfigured] (whose init receives an +// *[InitContext]); an agent whose constructor does not itself need config can +// still use the plain [Implement]. +// +// type ShopConfig struct{ Greeting string } +// var Shop = golem.DefineConfiguredAgent[ShopId, ShopConfig](golem.Spec{Name: "Shop"}) +func DefineConfiguredAgent[Id any, Cfg any](spec Spec) *AgentDefinition[Id, Cfg] { + return defineAgentInto[Id, Cfg](defs, spec) +} + +// defineAgentInto registers the agent's DEFINITION shell (name, mode, mount, +// snapshot policy, id fields, and config surface) on d and returns the handle. +// The constructor and the methods are attached later by [Implement]/[Bound]. +// Tests call it with their own definitions for full isolation. (It must stay a +// generic function — Go forbids generic methods.) +func defineAgentInto[Id any, Cfg any](d *definitions, spec Spec) *AgentDefinition[Id, Cfg] { + idType := reflect.TypeFor[Id]() + if spec.Name == "" { + d.recordErr("", "", "DefineAgent requires a non-empty Spec.Name (Id type %s)", idType) + return &AgentDefinition[Id, Cfg]{name: spec.Name} + } + if _, dup := d.agents[spec.Name]; dup { + d.recordErr(spec.Name, "", "agent type already defined") + return &AgentDefinition[Id, Cfg]{name: spec.Name} + } + if idType.Kind() != reflect.Struct { + // Record but still register (with no id fields) so a later Implement attaches + // rather than cascading into "unknown agent" errors. + d.recordErr(spec.Name, "", "Id must be a struct, got %s", idType) + } + 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 and the methods are attached by Implement; newState stays nil + // until then (an agent defined but never implemented fails at initialize). + } + 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 (Get), 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 &AgentDefinition[Id, 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 attaches an agent's constructor (init, which builds the private state +// from the constructor parameters) and returns a state-bound implementation +// handle. Put it in the agent's IMPLEMENTATION package, then register each method +// on the handle with [Handle]. The state type S is introduced here and stays +// private to this package — callers of the agent never see it. +// +// type state struct{ count int64 } +// var counter = golem.Implement(counteragent.Agent, func(counteragent.CounterId) *state { return &state{} }) +// func init() { +// golem.Handle(counter, counteragent.Add, func(ctx *golem.Context[state], in counteragent.AddIn) int64 { +// ctx.State.count += in.By +// return ctx.State.count +// }) +// } +// +// For an agent whose constructor reads config, use [ImplementConfigured]. +func Implement[Id any, S any, Cfg any]( + def *AgentDefinition[Id, Cfg], + init func(Id) *S, +) *AgentImpl[Id, S, Cfg] { + return implementInto[Id, S, Cfg](defs, def, simpleNewState[Id, S](init), init == nil) +} + +// ImplementConfigured is [Implement] for an agent whose constructor reads config: +// init receives an *[InitContext] carrying the id ([InitContext.ID]) and the +// config ([InitContext.Config]). +func ImplementConfigured[Id any, S any, Cfg any]( + def *AgentDefinition[Id, Cfg], + init func(*InitContext[Id, S, Cfg]) *S, +) *AgentImpl[Id, S, Cfg] { + return implementInto[Id, S, Cfg](defs, def, configuredNewState[Id, S, Cfg](init), init == nil) +} + +// Handle registers one method handler on the implementation handle returned by +// [Implement] / [ImplementConfigured]. S, In and Out are inferred from the +// handler, and Id must match the descriptor's agent, so binding a descriptor to +// the wrong agent, or a handler with the wrong signature or state type, is a +// compile error. Compose it with the method-expression adapters ([Bind] etc.) to +// author handlers as ordinary Go methods. Call it once per method — typically +// inside func init(). The handler is wrapped once, here, into a uniform +// dispatcher; dispatch itself never uses reflection to call it. +// +// 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. +func Handle[Id any, S any, Cfg any, In any, Out any]( + impl *AgentImpl[Id, S, Cfg], + m MethodDef[Id, In, Out], + h func(*Context[S], In) Out, +) Registered { + if impl != nil && impl.e != nil { + bindMethodInto[Id, S, In, Out](impl.d, impl.e, m, h) + } + return Registered{} +} + +// Registered is the result of [Handle]; it carries no data. It lets a Handle call +// sit in a package-level `var _ = golem.Handle(…)` as an alternative to calling it +// inside func init(). +type Registered struct{} + +func simpleNewState[Id any, S any](init func(Id) *S) func(reflect.Value, string) any { + if init == nil { + return nil + } + return func(idVal reflect.Value, _ string) any { return init(idVal.Interface().(Id)) } +} + +func configuredNewState[Id any, S any, Cfg any](init func(*InitContext[Id, S, Cfg]) *S) func(reflect.Value, string) any { + if init == nil { + return nil + } + // No host call here: the constructor reads config lazily via ctx.Config(), + // keeping get-config-value out of this always-linked path. + return func(idVal reflect.Value, agentID string) any { + return init(&InitContext[Id, S, Cfg]{id: idVal.Interface().(Id), agentID: agentID}) + } +} + +// implementInto registers the agent's constructor on its already-declared entry +// and returns the state-bound handle that [Handle] adds methods to. Tests call it +// with their own definitions for isolation. +func implementInto[Id any, S any, Cfg any]( + d *definitions, + def *AgentDefinition[Id, Cfg], + newState func(reflect.Value, string) any, + initNil bool, +) *AgentImpl[Id, S, Cfg] { + e := d.agents[def.name] + if e == nil { + d.recordErr(def.name, "", "Implement: unknown agent %q (was DefineAgent called?)", def.name) + return &AgentImpl[Id, S, Cfg]{d: d} + } + if initNil { + // Recorded, not fatal: init is only called from a successful initialize, + // gated on this agent having no definition errors. + d.recordErr(def.name, "", "Implement requires a non-nil init function") + } + if e.newState != nil { + d.recordErr(def.name, "", "agent already implemented") + return &AgentImpl[Id, S, Cfg]{d: d, e: e} + } + e.newState = newState + return &AgentImpl[Id, S, Cfg]{d: d, e: e} +} + +// bindMethodInto registers one method handler on an agent entry: it validates the +// descriptor, compiles the in/out codecs once (not per invocation), and installs +// the erased dispatcher (dispatch never uses reflection to reach the handler). +func bindMethodInto[Id any, S any, In any, Out any]( + d *definitions, + e *agentEntry, + m MethodDef[Id, In, Out], + h func(*Context[S], In) Out, +) { + if m.name == "" { + d.recordErr(e.name, "", "DefineMethod requires a non-empty method name") + return + } + if h == nil { + d.recordErr(e.name, m.name, "Handle requires a non-nil handler") + return + } + if m.descCount > 1 { + d.recordErr(e.name, m.name, "method %q: Desc set %d times (a method has one description)", m.name, m.descCount) + } + if m.readOnlyCount > 1 { + d.recordErr(e.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(e.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(e.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(e.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(e.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..1d8d656612 --- /dev/null +++ b/sdks/go/golem/registry_test.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 ( + "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 TestImplementRegistersMethods(t *testing.T) { + type Id struct{ Name string } + type St struct{ n int64 } + withDefs(t, func(d *definitions) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "Counter"}) + add := DefineMethod[Id, int64, int64]("add", Desc("adds to the counter")) + get := DefineMethod[Id, Unit, int64]("get") + + // Implement binds the constructor + returns the handle; Handle registers each + // method, In/Out inferred from the handler and tied to the agent's Id + St. + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, add, func(ctx *Context[St], in int64) int64 { ctx.State.n += in; return ctx.State.n }) + Handle(impl, get, Bind0(func(s *St) int64 { return s.n })) // method-expression style + + e := d.agents["Counter"] + if e == nil || e.methods["add"] == nil || e.methods["get"] == nil { + t.Fatal("Handle did not register the handlers under the agent") + } + if e.methods["add"].desc != "adds to the counter" { + t.Fatalf("desc = %q", e.methods["add"].desc) + } + noDefErrs(t, d) + }) +} + +func TestHandleRejectsDuplicateMethod(t *testing.T) { + type Id struct{ Name string } + type St struct{} + withDefs(t, func(d *definitions) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + m := DefineMethod[Id, Unit, Unit]("m") + h := func(*Context[St], Unit) Unit { return Unit{} } + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, m, h) + Handle(impl, m, h) + mustDefErr(t, d, "method already implemented") + }) +} + +func TestImplementRejectsSecondImplementAndNilInit(t *testing.T) { + type Id struct{ Name string } + type St struct{} + newState := simpleNewState[Id, St](func(Id) *St { return &St{} }) + withDefs(t, func(d *definitions) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A"}) + implementInto[Id, St, NoConfig](d, def, newState, false) + implementInto[Id, St, NoConfig](d, def, newState, false) // second time + mustDefErr(t, d, "already implemented") + }) + withDefs(t, func(d *definitions) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "B"}) + implementInto[Id, St, NoConfig](d, def, nil, true) // nil init + mustDefErr(t, d, "non-nil init") + }) +} + +func TestRegistrationErrorsAreRecorded(t *testing.T) { + type Id struct{ Name string } + type St struct{} + withDefs(t, func(d *definitions) { + defineAgentInto[Id, NoConfig](d, Spec{}) // empty Spec.Name + // Implement against an agent that was never defined. + implementInto[Id, St, NoConfig](d, &AgentDefinition[Id, NoConfig]{name: "does-not-exist"}, + simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + 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..6e7d8dda40 --- /dev/null +++ b/sdks/go/golem/retry/retry.go @@ -0,0 +1,987 @@ +// 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 per +// worker, not per goroutine. 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..20c45884ec --- /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..0a9e352d4d --- /dev/null +++ b/sdks/go/golem/rpc.go @@ -0,0 +1,301 @@ +// 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]. + +// noScopeCard is the permission scope card sent with every outgoing invocation. +// The Go SDK does not yet expose permission scoping, so calls carry no card +// (None) — behaviorally identical to before permission cards were introduced. +// TODO: expose PermissionCard on the client API (tracked follow-up). +func noScopeCard() witTypes.Option[*types.PermissionCard] { + return witTypes.None[*types.PermissionCard]() +} + +// 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, noScopeCard()) + 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, noScopeCard()) + 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) + } + res := c.rpc.ScheduleCancelableInvocation(instantFrom(at), m.name, tree, noScopeCard()) + if res.IsErr() { + panic(rpcErrorToGo(c.agentID, m.name, res.Err())) + } + receipt := res.Ok() + 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, noScopeCard()) + 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 = "" + } + 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..ae034711d0 --- /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]( + Spec{Name: "TestPayment", Mode: Durable}, +) + +var tCharge = DefineMethod[tPayId, tChargeIn, Money]("charge") + +func init() { + p := Implement(tPayment, func(id tPayId) *tPayState { return &tPayState{} }) + Handle(p, 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: ¬e} + + 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..5242d3c26a --- /dev/null +++ b/sdks/go/golem/snapshot.go @@ -0,0 +1,62 @@ +// 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. +// +// 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..15f6289c26 --- /dev/null +++ b/sdks/go/golem/snapshot_test.go @@ -0,0 +1,136 @@ +// 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) { + def := defineAgentInto[Id, NoConfig](d, Spec{Name: "A", Snapshot: c.policy}) + impl := implementInto[Id, St, NoConfig](d, def, simpleNewState[Id, St](func(Id) *St { return &St{} }), false) + Handle(impl, DefineMethod[Id, Unit, Unit]("m"), func(*Context[St], Unit) Unit { return Unit{} }) + 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..8ef09e1ad7 --- /dev/null +++ b/sdks/go/golem/testdata/wrong_client.go @@ -0,0 +1,33 @@ +//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 ChargeIn struct{ AmountCents int64 } + +type OrderID struct{ Number string } + +var Payment = golem.DefineAgent[PaymentID](golem.Spec{Name: "PaymentAgent"}) + +var Order = golem.DefineAgent[OrderID](golem.Spec{Name: "OrderAgent"}) + +// 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 := Order.Get(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..b3af3a5aba --- /dev/null +++ b/sdks/go/golem/transaction.go @@ -0,0 +1,168 @@ +// 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. +// +// Concurrency: a transaction opens a worker-global atomic region (there is 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. + +// 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. +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") and whose compensation +// succeeds (recording "c"). +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". +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..f79200d137 --- /dev/null +++ b/sdks/go/golem/types.go @@ -0,0 +1,370 @@ +// 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 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 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, or one arm of another Result. +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 +} + +// MustOk returns the success value, or panics with the failure as a Go error if +// the Result is a failure. It is the fail-loud shorthand for the common +// "propagate the failure" case and is equivalent to golem.Must(r.Get()): +// +// total := ledger.Record.Call(l, in).MustOk() +// +// The panic carries the Err arm as an error — a data-typed Err is wrapped in a +// [ResultError] recoverable via errors.As, matching [Result.Get]. Use the typed +// [Result.Ok]/[Result.Err] when you want the Err value in its own type. +func (r Result[Ok, Err]) MustOk() Ok { + if r.isErr { + panic(asGoError(r.err)) + } + 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 ([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 read failure has no in-band +// recovery, so it panics rather than returning an error; the panic surfaces as +// 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..c6adf88027 --- /dev/null +++ b/sdks/go/golem/types_test.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 ( + "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 || ok.MustOk() != 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() }) + mustPanic(t, "boom", func() { er.MustOk() }) +} + +// TestMustOkPanicsWithTypedError — MustOk panics with the same error Get() would +// return, so a recover() can pull the typed Err payload back out via errors.As. +func TestMustOkPanicsWithTypedError(t *testing.T) { + defer func() { + r := recover() + err, isErr := r.(error) + if !isErr { + t.Fatalf("MustOk should panic with an error, got %#v", r) + } + var re *ResultError[string] + if !errors.As(err, &re) || re.Value != "boom" { + t.Fatalf("panic did not carry the typed payload: %v", err) + } + }() + Err[int, string]("boom").MustOk() + t.Fatal("MustOk on a failed Result should have panicked") +} + +// 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..2a14266bbe --- /dev/null +++ b/sdks/go/golem/uuid/uuid.go @@ -0,0 +1,27 @@ +// 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 small leaf type. 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..ad401fb8e6 --- /dev/null +++ b/sdks/go/golem/variant.go @@ -0,0 +1,157 @@ +// 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. +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. +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..326498ab10 --- /dev/null +++ b/sdks/go/golem/websocket/websocket.go @@ -0,0 +1,215 @@ +// 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 means the connection could not be established or was lost. + ConnectionFailure ErrorKind = iota + // SendFailure means a message could not be sent. + SendFailure + // ReceiveFailure means a message could not be received. + ReceiveFailure + // ProtocolError means the peer violated the WebSocket protocol. + ProtocolError + // Closed means the peer closed the connection; CloseCode/CloseReason may carry + // the close frame. + Closed + // Other is any error the host did not classify. + 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; + + // retrieves a container by name + get-container: func(name: container-name) -> result; + + // 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; + + // 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; + + // returns container metadata + info: func() -> result; + + // 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; + + // creates or replaces an object with the data blob. + write-data: func(name: object-name, data: borrow) -> result<_, error>; + + // returns list of objects in the container. Order is undefined. + list-objects: func() -> result, 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) -> result<_, error>; + + // returns true if the object exists in this container + has-object: func(name: object-name) -> result; + + // returns metadata for the object + object-info: func(name: object-name) -> result; + + // 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) -> 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`. + // Soon: switch to `resource incoming-value { ... }` + resource incoming-value { + incoming-value-consume-sync: func() -> result, error>; + incoming-value-consume-async: func() -> result, 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>; + + /// Get the POSIX-style arguments to the program. + @since(version = 0.2.0) + get-arguments: func() -> list; + + /// 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; +} + +@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; +} + +/// 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; +} + +/// 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; +} + +@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>; + + /// Get the POSIX-style arguments to the program. + @since(version = 0.3.0) + get-arguments: func() -> list; + + /// 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; +} + +@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, future>>; +} + +@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) -> future>; +} + +@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) -> future>; +} + +/// 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; +} + +/// 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; +} + +/// 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; +} + +@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; + + /// 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; + + /// 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`. 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, 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>, 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, + /// Last data modification timestamp. + /// + /// If the `option` is none, the platform doesn't maintain a + /// modification timestamp for this file. + data-modification-timestamp: option, + /// 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, + } + + /// 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; + /// 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; + /// 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; + /// 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; + /// 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; + /// 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`. + /// + /// Note: This is similar to `pread` in POSIX. + @since(version = 0.2.0) + read: func(length: filesize, offset: filesize) -> result, 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`. + /// + /// Note: This is similar to `pwrite` in POSIX. + @since(version = 0.2.0) + write: func(buffer: list, offset: filesize) -> result; + /// 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; + /// 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; + /// 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; + /// 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, 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; + /// 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; + /// 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, 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) -> 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; + /// 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; + } + + /// 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, 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) -> option; +} + +@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>; +} + +@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), + } + + /// 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, + /// Last data modification timestamp. + /// + /// If the `option` is none, the platform doesn't maintain a + /// modification timestamp for this file. + data-modification-timestamp: option, + /// 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, + } + + /// 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), + } + + /// 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, future>>; + /// 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, offset: filesize) -> future>; + /// 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) -> future>; + /// 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; + /// 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; + /// 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, future>>; + /// 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; + /// 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; + /// 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, 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; + /// 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; + /// 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, 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) -> 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; + /// 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; + } +} + +@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>; +} + +@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); + + /// 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; + + /// 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; + + /// 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; + + /// 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; + + /// Gets all values of all attributes of the current invocation context. + get-attribute-chains: func() -> list; + + /// Gets the W3C Trace Context headers associated with the current invocation context + trace-context-headers: func() -> list>; + } + + /// 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 + } + + /// 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..3df52e154f --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-1.x/golem-host.wit @@ -0,0 +1,312 @@ +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, 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, + } + + /// 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 + } + + /// Combines multiple groups of filter conditions with an `OR` relationship for enumerating agents + record agent-any-filter { + filters: list + } + + /// 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, + /// Environment variables seen by the agent + env: list>, + /// Configuration variables seen by the agent + config: list>, + /// 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, precise: bool); + + /// Retrieves the next batch of agent metadata. + get-next: func() -> result>, agent-operation-error>; + } + + /// 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) + } + + /// Error returned by an operation targeting another agent. + variant agent-operation-error { + permission-denied, + backend-error(string), + } + + /// 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; + } + + /// 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) -> 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 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; + + /// 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) -> result<_, agent-operation-error>; + + /// Get the current agent's metadata + get-self-metadata: func() -> result; + + /// Get agent metadata + get-agent-metadata: func(agent-id: agent-id) -> option; + + /// 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) -> result<_, agent-operation-error>; + + /// Revert an agent to a previous state + revert-agent: func(agent-id: agent-id, revert-target: revert-agent-target) -> result<_, agent-operation-error>; + + /// 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; + + /// 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; + + /// 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; + + /// 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() -> result; + + /// Snapshot payload + record snapshot { + payload: list, + 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>, component-id: component-id, agent-id: agent-id, metadata: agent-metadata, first-entry-index: oplog-index, entries: list) -> 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..a2370af1f9 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-1.x/golem-oplog.wit @@ -0,0 +1,997 @@ +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, 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, + } + + 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), + write-remote-transaction(option) + } + + record plugin-installation-description { + environment-plugin-grant-id: environment-plugin-grant-id, + plugin-priority: s32, + plugin-name: string, + plugin-version: string, + parameters: list> + } + + record raw-local-agent-config-entry { + path: list, + value: schema-value-tree + } + + record local-agent-config-entry { + path: list, + value: typed-schema-value + } + + record create-parameters { + timestamp: datetime, + agent-id: agent-id, + agent-mode: agent-mode, + component-revision: component-revision, + env: list>, + created-by: account-id, + environment-id: environment-id, + parent: option, + component-size: u64, + initial-total-linear-memory-size: u64, + initial-active-plugins: list, + local-agent-config: list, + original-phantom-id: option, + 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, + function-name: string, + invocation-id: option, + observational-owner: option, + request: option, + 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, + 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, + } + + /// 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, + } + + /// Parameters of a `completion-delivered` entry: the successful result of the durable host + /// call started at `start-index` was handed to the agent at this point in the recorded + /// execution. Replay may prepare the recorded host result earlier, but does not hand it to the + /// agent until this marker and prevents later oplog entries from advancing until that handoff. + record completion-delivered-parameters { + timestamp: datetime, + start-index: oplog-index, + } + + record local-span-data { + span-id: span-id, + start: datetime, + parent: option, + /// Optionally an index of the invocation-context field within agent-invocation + linked-context: option, + attributes: list, + 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, + 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, + } + + 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, + card-id: card-id, + } + + /// Raw parameters for a card-installed oplog entry. + record raw-card-installed-parameters { + timestamp: datetime, + queued-event-index: option, + card: list, + } + + 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, + invocation-context: list>, + } + + record agent-method-invocation-parameters { + idempotency-key: string, + method-name: string, + function-input: typed-schema-value, + trace-id: string, + trace-states: list, + invocation-context: list>, + } + + 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, + } + + 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 + } + + record failed-update-parameters { + timestamp: datetime, + target-revision: component-revision, + details: option + } + + 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, + linked-context-id: option, + attributes: list, + } + + 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 begin-remote-transaction-parameters { + timestamp: datetime, + transaction-id: string + } + + record remote-transaction-parameters { + timestamp: datetime, + begin-index: oplog-index + } + + record snapshot-data { + data: list, + 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), + external(oplog-external-payload) + } + + record oplog-external-payload { + payload-id: uuid, + md5-hash: list + } + + 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>, + environment-id: environment-id, + created-by: account-id, + parent: option, + component-size: u64, + initial-total-linear-memory-size: u64, + initial-active-plugins: list, + local-agent-config: list, + original-phantom-id: option, + instance-id: uuid + } + + record raw-start-parameters { + timestamp: datetime, + parent-start-index: option, + function-name: string, + invocation-id: option, + observational-owner: option, + request: option, + durable-function-type: wrapped-function-type, + } + + record raw-end-parameters { + timestamp: datetime, + start-index: oplog-index, + response: option, + forced-commit: bool, + } + + record raw-cancelled-parameters { + timestamp: datetime, + start-index: oplog-index, + partial: option, + } + + record raw-completion-discarded-parameters { + timestamp: datetime, + start-index: oplog-index, + } + + record raw-completion-delivered-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, + invocation-context: list, + } + + record raw-agent-invocation-finished-parameters { + timestamp: datetime, + %result: oplog-payload, + method-name: option, + 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, + } + + record raw-pending-agent-invocation-parameters { + timestamp: datetime, + idempotency-key: string, + payload: oplog-payload, + trace-id: string, + trace-states: list, + invocation-context: list, + } + + /// 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 + } + + 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 + } + + 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), + /// 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), + /// The successful completion of the durable host call started by the matching `start` + /// was delivered to the agent at this point in the recorded execution + completion-delivered(raw-completion-delivered-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), + /// 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), + /// The successful completion of the durable host call started by the matching `start` + /// was delivered to the agent at this point in the recorded execution + completion-delivered(completion-delivered-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>, component-revision: component-revision) -> result, string>; + + variant oplog-read-error { + permission-denied, + internal-error(string), + } + + resource get-oplog { + constructor(agent-id: agent-id, start: oplog-index); + get-next: func() -> result>, oplog-read-error>; + } + + resource search-oplog { + constructor(agent-id: agent-id, text: string); + get-next: func() -> result>>, oplog-read-error>; + } +} 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, + } + + 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), + pred-or(tuple), + 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, + } + + 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, + } + + 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-union(tuple), + policy-intersect(tuple), + } + + 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; + + /// Get a specific retry policy by name + get-retry-policy-by-name: func(name: string) -> option; + + /// 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>, + ) -> option; + + /// 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, + dependencies: list, + mode: agent-mode, + http-mount: option, + snapshotting: snapshotting, + config: list, + } + + /// 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, + schema: schema-graph, + %constructor: agent-constructor, + methods: list, + } + + /// Ordered, named input parameters with per-field source annotation. + variant input-schema { + parameters(list), + } + + 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, + prompt-hint: option, + input-schema: input-schema, + output-schema: output-schema, + read-only: option, + } + + 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, + auth-details: option, + phantom-agent: bool, + cors-options: cors-options, + webhook-suffix: list, + } + + record cors-options { + allowed-patterns: list, + } + + record http-endpoint-details { + http-method: http-method, + path-suffix: list, + header-vars: list, + query-vars: list, + auth-details: option, + 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, + name: option, + email-verified: option, + given-name: option, + family-name: option, + picture: option, + preferred-username: option, + + claims: string, + } + + record agent-principal { + agent-id: agent-id, + } + + record golem-user-principal { + account-id: account-id + } + + record agent-constructor { + name: option, + description: string, + prompt-hint: option, + 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, + /// Index into the owning agent-type `schema` graph. + value-type: type-node-index, + } + + record typed-agent-config-value { + path: list, + 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, 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, 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..14d5d2df88 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-agent/host.wit @@ -0,0 +1,152 @@ +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, permission-card}; + 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; + + /// Get a specific registered agent type by name + get-agent-type: func(agent-type-name: string) -> option; + + /// 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) -> result; + + /// 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>, 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. + variant webhook-error { + permission-denied, + internal-error(string), + } + + create-webhook: func(promise-id: promise-id) -> result; + + /// 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, + } + + /// 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, agent-config: list); + + /// 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, scope-card: option>) -> result; + + /// 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, scope-card: option>) -> result; + + /// 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, scope-card: option>) -> 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, scope-card: option>) -> result; + + /// 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, scope-card: option>) -> result; + } + + /// Represents an asynchronous invocation result + resource future-invoke-result { + /// Awaits the result of the invocation. + get: async func() -> result, 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. + variant config-value-error { + permission-denied, + } + + get-config-value: func(key: list, expected: schema-graph) -> result; +} 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..041298d569 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-core-v2/golem-core-v2.wit @@ -0,0 +1,632 @@ +// 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; + + /// 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; + + /// An unforgeable handle to a permission card held by the runtime. The + /// handle is opaque to guests: components can hold, pass, derive, install, + /// and revoke cards only through the `golem:permissions` interfaces. When + /// carried in a `schema-value-tree` (see + /// `schema-value-node::permission-card-handle`) the handle is transferred + /// by ownership; the host converts it to/from its internal trusted + /// card-store representation at the boundary. The wire form is the card-id + /// (UUID) alone — no grants, parents, or metadata cross the wire as + /// authority. + resource permission-card; + + // ============================================================ + // 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, + /// 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, + /// 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, + /// 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, + aliases: list, + /// 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, + /// Deprecation message; `none` means not deprecated. + deprecated: option, + /// Optional role annotation tagging a type with a consumer-facing intent. + role: option, + } + + /// Open registry; unknown roles fall back to structural handling. + variant role { + /// `list>` 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), + s16-type(option), + s32-type(option), + s64-type(option), + u8-type(option), + u16-type(option), + u32-type(option), + u64-type(option), + f32-type(option), + f64-type(option), + char-type, + string-type, + + // --- Structural composites --- + record-type(list), + variant-type(list), + enum-type(list), + flags-type(list), + tuple-type(list), + 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), + permission-card-type(permission-card-spec), + + // --- WASI P3 stubs (parseable only; no semantics yet) --- + future-type(option), + stream-type(option), + } + + record named-field-type { + name: string, + body: type-node-index, + metadata: metadata-envelope, + } + + record variant-case-type { + name: string, + payload: option, + 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, + err: option, + } + + // --- 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, + max: option, + unit: option, + } + + // --- Text / Binary restrictions --- + + record text-restrictions { + /// Optional set of allowed BCP-47 language codes. `none` = unrestricted. + languages: option>, + min-length: option, + max-length: option, + regex: option, + } + + record binary-restrictions { + /// Optional set of allowed MIME types. `none` = unrestricted. + mime-types: option>, + min-bytes: option, + max-bytes: option, + } + + // --- 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>, + allowed-extensions: option>, + } + + // --- URL --- + + record url-restrictions { + allowed-schemes: option>, + allowed-hosts: option>, + } + + // --- 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, + /// Optional inclusive range, expressed in canonical fixed-point form. + min: option, + max: option, + } + + // --- 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. + // + // Portable schema-construction contract: + // - branch `tag`s are unique within the union, + // - string-pattern discriminators (`prefix` / `suffix` / `contains` / + // `regex`) require a branch body whose canonical raw JSON + // representation is a string (`string-type`, `url-type`, `path-type`, + // or a `ref` resolving to one), + // - `field-equals` requires a record-shaped branch body that declares + // the referenced field; a literal additionally requires that field to + // have a canonical raw JSON string representation, + // - `field-absent` requires a record-shaped branch body that does not + // declare the referenced field, + // - byte-identical regex text is rejected first as duplicate syntax, + // without making a semantic claim about the regex language, + // - every remaining pair of discriminator rules is classified as + // overlapping, disjoint, or indeterminate. Overlapping pairs are rejected; + // disjoint and indeterminate pairs are accepted. Runtime decoders + // still reject a raw value that matches multiple accepted branches. + // + // The canonical pair classification is symmetric and based only on the + // raw discriminator rules; branch body schemas do not refine it: + // - two prefixes overlap exactly when either prefixes the other, + // - two suffixes overlap exactly when either suffixes the other, + // - every prefix/suffix, prefix/contains, suffix/contains, and + // contains/contains pair overlaps, + // - a string-pattern rule and a record-shaped rule are disjoint because + // a raw JSON value cannot be both a string and an object, + // - field-equals rules on different fields overlap; on the same field + // they are disjoint only when both literals are present and differ, + // - every pair of field-absent rules overlaps, + // - field-equals and field-absent are disjoint on the same field and + // overlap on different fields, + // - after the duplicate-syntax check above, every pair containing a + // regex and another string-pattern rule is indeterminate and accepted. + // No portable semantic regex-overlap analysis is attempted because SDK + // regex dialects differ. + + record union-spec { + branches: list, + } + + 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 has a match for this regex in the implementation's + /// regex dialect. The pattern must include anchors when whole-string + /// matching is required. + 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, + } + + // --- 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, + } + + record quota-token-spec { + /// Resource name this token covers (e.g., declared in the agent manifest). + /// `none` = any resource permitted. + resource-name: option, + } + + record permission-card-spec { + /// `true` = polymorphic (carries slot variables in owner / resource-id), + /// `false` = monomorphic. Structural metadata only; authority lives in + /// the card store, not in the schema spec. + polymorphic: bool, + } + + // ============================================================ + // 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, + 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), + variant-value(variant-value-payload), + enum-value(u32), + flags-value(list), + tuple-value(list), + list-value(list), + fixed-list-value(list), + map-value(list), + option-value(option), + 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), + quota-token-handle(own), + permission-card-handle(own), + + // WASI P3 stubs (parseable only in the schema; no constructible values). + } + + record variant-value-payload { + case: u32, + payload: option, + } + + 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), + err-value(option), + } + + record text-value-payload { + text: string, + /// BCP-47 language tag, when known. + language: option, + } + + record binary-value-payload { + bytes: list, + mime-type: option, + } + + /// 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..8f39e1947d --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-durability/golem-durability.wit @@ -0,0 +1,75 @@ +package golem:durability@1.6.0; + +interface durability { + use golem:api/oplog@1.5.0.{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; + + /// A live custom durable invocation. + /// + /// Host effects initiated while this resource is active are recorded as replay-inert + /// observational entries belonging to the invocation. Finishing consumes the resource and + /// persists the response. Dropping it without finishing leaves the invocation incomplete so + /// normal recovery re-executes it. + resource live-custom-durable-invocation { + /// Completes the invocation with its schema-carrying response. + finish: static func( + this: live-custom-durable-invocation, + response: typed-schema-value, + forced-commit: bool, + ); + } + + /// 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 + } + + /// The result of opening a custom durable invocation. + variant custom-durable-invocation { + /// Execute the operation body and finish the returned live invocation. + live(live-custom-durable-invocation), + /// Return the recorded response without executing the operation body. + replayed(persisted-durable-function-invocation), + } + + /// Observes a function call (produces logs and metrics) + observe-function-call: func(iface: string, function: string); + + /// Opens a custom durable invocation. + /// + /// The executor allocates a deterministic identity synchronously when the call begins. A fresh + /// or incomplete invocation returns an owned `live-custom-durable-invocation`. A completed + /// invocation returns `replayed` with its recorded response. + begin-custom-durable-invocation: func( + function-name: string, + request: typed-schema-value, + function-type: durable-function-type, + ) -> custom-durable-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-permissions/derive.wit b/sdks/go/golem/wit/deps/golem-permissions/derive.wit new file mode 100644 index 0000000000..a1cd9f06b6 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-permissions/derive.wit @@ -0,0 +1,42 @@ +package golem:permissions@0.1.0; + +/// Derivation of new permission cards from an existing card or from the +/// caller's wallet. +/// +/// Derivation narrows authority: a child card's lattice is bounded by its +/// parent's lattice. The caller specifies which lower-positive and +/// upper-positive grants to retain and which lower-negative and +/// upper-negative grants to add, plus an optional lifespan. +interface derive { + use golem:core/types@2.0.0.{permission-card}; + use types.{pattern-grant, permission-error, duration}; + + /// Derive a child card from `parent`, narrowing the grant lattice. + derive: func( + parent: borrow, + lower-positive-to-retain: list, + lower-negative-to-add: list, + upper-positive-to-retain: list, + upper-negative-to-add: list, + lifespan: option, + ) -> result; + + /// Derive a card directly from the caller's wallet. + derive-from-wallet: func( + lower-positive: list, + lower-negative: list, + upper-positive: list, + upper-negative: list, + lifespan: option, + ) -> result; + + /// Derive an invocation-local card from one or more persistent or scope + /// parents. Scope cards are attenuated in-memory and are never persisted. + derive-scope: func( + parents: list>, + lower-positive: list, + lower-negative: list, + upper-positive: list, + upper-negative: list, + ) -> result; +} diff --git a/sdks/go/golem/wit/deps/golem-permissions/inspect.wit b/sdks/go/golem/wit/deps/golem-permissions/inspect.wit new file mode 100644 index 0000000000..34481974fd --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-permissions/inspect.wit @@ -0,0 +1,14 @@ +package golem:permissions@0.1.0; + +/// Read-only inspection of a permission card's full grant lattice. +/// +/// Returns the four quadrants of the card's bound lattice +/// (lower/upper × positive/negative) as a `card-view`. Importing this +/// interface grants no authority to mutate or derive cards. +interface inspect { + use golem:core/types@2.0.0.{permission-card}; + use types.{card-view, permission-error}; + + /// Return the card's complete grant lattice. + inspect-card: func(c: borrow) -> result; +} diff --git a/sdks/go/golem/wit/deps/golem-permissions/kernel-introspection.wit b/sdks/go/golem/wit/deps/golem-permissions/kernel-introspection.wit new file mode 100644 index 0000000000..d555454b01 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-permissions/kernel-introspection.wit @@ -0,0 +1,20 @@ +package golem:permissions@0.1.0; + +/// Introspection of the permission kernel's registered resource classes and +/// verbs, and validation of individual grants against the kernel's schema. +interface kernel-introspection { + use types.{pattern-grant, permission-error}; + + record kernel-module { + class-name: string, + verbs: list, + } + + /// List every resource class the kernel knows about, with their + /// permitted verbs. + list-modules: func() -> list; + + /// Validate that `g` references a known class, owner, recipient, verb, + /// and resource-id pattern accepted by the kernel. + validate-grant: func(g: pattern-grant) -> result<_, permission-error>; +} diff --git a/sdks/go/golem/wit/deps/golem-permissions/revoke.wit b/sdks/go/golem/wit/deps/golem-permissions/revoke.wit new file mode 100644 index 0000000000..da2fb7975a --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-permissions/revoke.wit @@ -0,0 +1,15 @@ +package golem:permissions@0.1.0; + +/// Revocation of a permission card and its derivation DAG subtree. +/// +/// `revoke-card` consumes the owned handle (the receiving component's +/// resource-table entry is deleted); the stored card is walked via the card +/// store's DAG descendant index. Returns the cut-subtree size. +interface revoke { + use golem:core/types@2.0.0.{permission-card}; + use types.{permission-error}; + + /// Revoke `c` and every card transitively derived from it. + /// Consumes the owned handle. + revoke-card: func(c: permission-card) -> result; +} diff --git a/sdks/go/golem/wit/deps/golem-permissions/types.wit b/sdks/go/golem/wit/deps/golem-permissions/types.wit new file mode 100644 index 0000000000..2fb749ed60 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-permissions/types.wit @@ -0,0 +1,82 @@ +package golem:permissions@0.1.0; + +/// The permission-card resource's shared data model and inspection operations. +/// +/// The `permission-card` capability itself is defined as a bare resource in +/// `golem:core/types` so that it can travel inside a `schema-value-tree` as an +/// opaque, unforgeable handle. This interface exposes only safe inspection +/// operations over that handle plus the records and variants the other +/// permissions interfaces reference. Components that only need to *hold and +/// pass* cards — most tools and middleware — import only this interface. +interface types { + use golem:core/types@2.0.0.{permission-card, card-id, agent-id, uuid}; + + record timestamp { + seconds: s64, + nanoseconds: u32, + } + + /// ISO-8601 duration string (e.g. `"P30D"` for 30 days). + record duration { + iso-8601: string, + } + + variant holder { + account(uuid), + app(uuid), + agent(agent-id), + } + + record pattern-grant { + class: string, + owner: string, + recipient: string, + verb: string, + resource-id: string, + } + + record card-view { + lower-positive: list, + lower-negative: list, + upper-positive: list, + upper-negative: list, + } + + record wallet-version-token { + /// 32 bytes — BLAKE3 of (holder-kind, holder-id). + wallet-id-hash: list, + generation: u64, + } + + variant permission-error { + not-permitted(string), + lower-bound-too-broad(string), + upper-bound-too-broad(string), + wallet-multi-source-required(string), + card-revoked(string), + card-expired(string), + install-recipient-mismatch(string), + card-polymorphic-not-usable(string), + unknown-resource-class(string), + invalid-pattern(string), + invalid-verb(string), + invalid-owner(string), + invalid-recipient(string), + } + + // --- Card inspection --- + // Free functions on a borrowed handle, because the resource itself is + // bare in core (matching secret/quota-token). + + /// Stable identifier of this card. + id: func(c: borrow) -> card-id; + + /// Parent card identifiers in the derivation DAG. + parents: func(c: borrow) -> list; + + /// Expiry timestamp, if the card has a bounded lifespan. + expires-at: func(c: borrow) -> option; + + /// `true` if the card is polymorphic (carries slot variables). + is-polymorphic: func(c: borrow) -> bool; +} diff --git a/sdks/go/golem/wit/deps/golem-permissions/wallet.wit b/sdks/go/golem/wit/deps/golem-permissions/wallet.wit new file mode 100644 index 0000000000..818d8b1538 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-permissions/wallet.wit @@ -0,0 +1,23 @@ +package golem:permissions@0.1.0; + +/// Wallet operations: enumerate the caller's installed cards, query the +/// wallet's version token, and install a card onto a target holder. +interface wallet { + use golem:core/types@2.0.0.{permission-card}; + use types.{permission-error, wallet-version-token, holder}; + + /// All permission cards currently installed in the caller's wallet. + self-wallet: func() -> list; + + /// Version token for the caller's wallet, changed whenever the set of + /// installed cards changes. + self-version: func() -> wallet-version-token; + + /// Install `card` onto `target`. Returns unit on success. + /// + /// Only agent targets are currently supported. Account and application + /// targets return `not-permitted("install-card currently supports only + /// agent targets")` before any wallet or oplog mutation. + install-card: func(card: permission-card, target: holder) + -> result<_, permission-error>; +} 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, + } + + /// 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, + amount: u64, + ) -> result; + + /// 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, + 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, + 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), + /// Milliseconds since Unix epoch (UTC). + db-date(s64), + /// (milliseconds since epoch, sub-millisecond nanoseconds 0..999_999). + db-timestamp(tuple), + /// Nanoseconds since midnight. + db-time(s64), + db-decimal(string), + db-byte-array(list), + } + + // ── Metadata ─────────────────────────────────────────────────────────────── + record db-column { ordinal: u64, name: string } + record db-row { values: list } + record db-result { columns: list, rows: list } + + // ── Resources ────────────────────────────────────────────────────────────── + resource db-result-stream { + get-columns: func() -> result, error>; + get-next: func() -> result>, error>; + } + + resource db-transaction { + query: func(statement: string, params: list) -> result; + query-stream: func(statement: string, params: list) -> result; + execute: func(statement: string, params: list) -> result; + 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; + query: func(statement: string, params: list) -> result; + query-stream: func(statement: string, params: list) -> result; + execute: func(statement: string, params: list) -> result; + begin-transaction: func() -> result; + } +} 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), + varbinary(list), + tinyblob(list), + blob(list), + mediumblob(list), + longblob(list), + enumeration(string), + set(string), + bit(list), + json(string), + null + } + + /// A single row of values + record db-row { + values: list + } + + record db-result { + columns: list, + rows: list + } + + /// A potentially very large and lazy stream of rows: + resource db-result-stream { + get-columns: func() -> list; + get-next: func() -> option>; + } + + resource db-connection { + open: static func(address: string) -> result; + + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + begin-transaction: func() -> result; + } + + resource db-transaction { + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + 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> + } + + record composite { + name: string, + values: list + } + + 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, + values: list + } + + 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), + json(string), + jsonb(string), + jsonpath(string), + xml(string), + uuid(uuid), + inet(ip-address), + cidr(ip-address), + macaddr(mac-address), + bit(list), + varbit(list), + int4range(int4range), + int8range(int8range), + numrange(numrange), + tsrange(tsrange), + tstzrange(tstzrange), + daterange(daterange), + money(s64), + oid(u32), + enumeration(enumeration), + composite(composite), + domain(domain), + array(list), + range(range), + null, + vector(list), + halfvec(list), + 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 + } + + record db-result { + columns: list, + rows: list + } + + /// A potentially very large and lazy stream of rows: + resource db-result-stream { + get-columns: func() -> list; + get-next: func() -> option>; + } + + resource db-connection { + open: static func(address: string) -> result; + + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + begin-transaction: func() -> result; + } + + resource db-transaction { + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + 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), + ipv6(tuple), + } + + record mac-address { + octets: tuple + } + + 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` 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, expected: schema-graph) + -> result; +} 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, + } + + record secret-metadata { + /// Config-key path the secret resolved from, when applicable. + /// `none` for secrets returned in tool-result position. + config-key: option>, + /// 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, + /// 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, + } + + /// 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, + } + + /// 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-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-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..06985d25d7 --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-tool/common.wit @@ -0,0 +1,411 @@ +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 are pairwise unique, AND unique against +/// the long-names + aliases of globals inherited from any ancestor. +/// • Option and flag short forms occupy a separate `char` namespace: +/// they are pairwise unique with other short forms in the body and with +/// inherited global short forms. A string name or alias such as `"f"` +/// does not collide with the short form `'f'`. +/// • Constraint `ref` string names resolve against body-declared long-names, +/// positional names, aliases, and globals inherited from any ancestor; +/// short forms do not participate in constraint resolution. +/// • 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, + } + + record tool-middleware { + name: string, + aliases: list, + doc: doc, + scope: tool-middleware-scope, + } + + variant tool-middleware-scope { + monomorphic(monomorphic-scope), + universal, + } + + record monomorphic-scope { + presented: tool, + expected: option, + } + + // Command tree + type command-index = s32; + + record command-tree { + /// Always non-empty; the root command is at index 0. + nodes: list, + } + + /// 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, + doc: doc, + globals: globals, + subcommands: list, + body: option, + } + + record globals { + options: list, + %flags: list, + } + + record command-body { + positionals: positionals, + options: list, + %flags: list, + constraints: list, + stdin: option, + stdout: option, + %result: option, + errors: list, + annotations: option, + } + + /// 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, + tail: option, + } + + record positional { + name: string, + doc: doc, + value-name: option, + /// Index into `tool.schema`. + %type: type-node-index, + /// Default value, interpreted against `%type` in `tool.schema`. + default: option, + 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, + /// Index into `tool.schema`. + item-type: type-node-index, + min: u32, + max: option, + /// Token required before tail items (e.g. "--" for `git log -- `). + separator: option, + /// 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, + aliases: list, + doc: doc, + value-name: option, + shape: option-shape, + /// Default value, interpreted against the option's type node in + /// `tool.schema`. + default: option, + required: bool, + env-var: option, + } + + 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`. + 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, + aliases: list, + doc: doc, + shape: flag-shape, + env-var: option, + } + + variant flag-shape { + bool-flag(bool-flag-shape), + /// Counted flag (-vvv); optional max count. + count-flag(option), + } + + record bool-flag-shape { + default: bool, + /// If true, --no- 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), + all-or-none(list), + requires-any(list), + mutex-groups(list), + implies(implies-c), + forbids(forbids-c), + } + + record ref-group { + refs: list, + } + + record implies-c { + lhs-quant: quantifier, + lhs: list, + rhs-quant: quantifier, + rhs: list, + } + + record forbids-c { + lhs-quant: quantifier, + lhs: list, + rhs: list, + } + + enum quantifier { all, any } + + // Streams, structured results, errors + record stream-spec { + doc: doc, + mime: list, + required: bool, + } + + record result-spec { + /// Index into `tool.schema`. + %type: type-node-index, + doc: doc, + formatters: list, + 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, + } + + enum error-kind { usage-error, runtime-error } + + // Documentation, examples + record doc { + summary: string, + description: string, + examples: list, + } + + record example { + title: string, + body: string, + } + + // Invocation contract — shared between guest and host + variant tool-error { + invalid-tool-name(string), + invalid-command-path(list), + 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, + stdout: option>, + } + + /// Invocation-scoped access to exactly the next inner layer in a tool + /// middleware chain. The runtime creates this resource; guests cannot. + resource underlying-tool { + invoke: async func( + command-path: list, + input: typed-schema-value, + stdin: option>, + ) -> result; + } +} 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, tool-error>; + + /// Look up a single tool by name. + get-tool: func(name: string) -> result; + + /// 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, + input: typed-schema-value, + stdin: option>, + principal: principal, + ) -> result; +} + +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..4d4b724cce --- /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; + + /// 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; + + 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, + input: typed-schema-value, + stdin: option>, + ) -> result; + + invoke: async func( + command-path: list, + input: typed-schema-value, + stdin: option>, + ) -> result<_, rpc-error>; + + async-invoke-and-await: async func( + command-path: list, + input: typed-schema-value, + stdin: option>, + ) -> future-invoke-result; + } + + resource future-invoke-result { + get: async func() -> result; + cancel: func(); + } +} + +world tool-host { + export host; +} diff --git a/sdks/go/golem/wit/deps/golem-tool/middleware.wit b/sdks/go/golem/wit/deps/golem-tool/middleware.wit new file mode 100644 index 0000000000..fa3200d28e --- /dev/null +++ b/sdks/go/golem/wit/deps/golem-tool/middleware.wit @@ -0,0 +1,42 @@ +package golem:tool@0.1.0; + +/// Interface exported by components that provide tool middleware. +interface tool-middleware-guest { + use common.{invocation-result, tool, tool-error, tool-middleware, underlying-tool}; + use golem:agent/common@2.0.0.{principal}; + use golem:core/types@2.0.0.{typed-schema-value}; + + /// Enumerate every middleware definition exported by this component. + discover-tool-middlewares: func() -> result, tool-error>; + + /// Look up one middleware definition by canonical name. + get-tool-middleware: func(name: string) -> result; + + /// Invoke one middleware layer around its runtime-bound next inner layer. + invoke-tool-middleware: async func( + middleware-name: string, + tool-name: string, + tool-metadata: tool, + command-path: list, + input: typed-schema-value, + stdin: option>, + principal: principal, + wrapped: underlying-tool, + ) -> result; +} + +/// Pure middleware components cannot re-enter ambient tool dispatch. They can +/// reach only the next inner layer through the runtime-owned resource. +world tool-middleware { + import golem:api/host@1.5.0; + import golem:agent/host@2.0.0; + import common; + export tool-middleware-guest; +} + +/// Components may opt into exporting ordinary agents and tools together with +/// middleware. The included tool world retains its ambient tool-host import. +world tool-and-tool-middleware-guest { + include tool-guest; + export tool-middleware-guest; +} 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), + other(string), + } + + record close-info { + code: u16, + reason: string, + } + + /// A WebSocket message — text or binary + variant message { + text(string), + binary(list), + } + + /// 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>> + ) -> result; + + /// Send a message (text or binary) + send: func(message: message) -> result<_, error>; + + /// Receive the next message (blocks until available) + receive: async func() -> result; + + /// 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, error>; + + /// Send a close frame with optional code and reason + close: func(code: option, reason: option) -> 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, + info-code: option, + } + + /// Defines the case payload type for `TLS-alert-received` above: + @since(version = 0.2.0) + record TLS-alert-received-payload { + alert-id: option, + alert-message: option, + } + + /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above: + @since(version = 0.2.0) + record field-size-payload { + field-name: option, + field-size: option, + } + + /// These cases are inspired by the IANA 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), + HTTP-request-method-invalid, + HTTP-request-URI-invalid, + HTTP-request-URI-too-long, + HTTP-request-header-section-size(option), + HTTP-request-header-size(option), + HTTP-request-trailer-section-size(option), + HTTP-request-trailer-size(field-size-payload), + HTTP-response-incomplete, + HTTP-response-header-section-size(option), + HTTP-response-header-size(field-size-payload), + HTTP-response-body-size(option), + HTTP-response-trailer-section-size(option), + HTTP-response-trailer-size(field-size-payload), + HTTP-response-transfer-coding(option), + HTTP-response-content-coding(option), + 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), + } + + /// 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; + + /// 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>) -> result; + /// 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; + /// 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) -> 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>; + /// 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; + /// Returns the protocol scheme from the request. + @since(version = 0.2.0) + scheme: func() -> option; + /// Returns the authority of the Request's target URI, if present. + @since(version = 0.2.0) + authority: func() -> option; + /// 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; + } + + /// 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; + /// 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; + /// 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) -> 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; + /// 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) -> 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; + /// 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) -> 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; + /// 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) -> result; + /// The timeout for receiving the first byte of the Response body. + @since(version = 0.2.0) + first-byte-timeout: func() -> option; + /// 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) -> result; + /// The timeout for receiving subsequent chunks of bytes in the Response + /// body stream. + @since(version = 0.2.0) + between-bytes-timeout: func() -> option; + /// 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) -> 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); + } + + /// 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; + } + + /// 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; + /// 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, 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; + } + + /// 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; + /// 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) -> 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>>; + } + + /// 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) -> option; +} + +/// 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) -> result; +} + +/// 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, + info-code: option, + } + + /// Defines the case payload type for `TLS-alert-received` above: + @since(version = 0.3.0) + record TLS-alert-received-payload { + alert-id: option, + alert-message: option, + } + + /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above: + @since(version = 0.3.0) + record field-size-payload { + field-name: option, + field-size: option, + } + + /// These cases are inspired by the IANA 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), + HTTP-request-method-invalid, + HTTP-request-URI-invalid, + HTTP-request-URI-too-long, + HTTP-request-header-section-size(option), + HTTP-request-header-size(option), + HTTP-request-trailer-section-size(option), + HTTP-request-trailer-size(field-size-payload), + HTTP-response-incomplete, + HTTP-response-header-section-size(option), + HTTP-response-header-size(field-size-payload), + HTTP-response-body-size(option), + HTTP-response-trailer-section-size(option), + HTTP-response-trailer-size(field-size-payload), + HTTP-response-transfer-coding(option), + HTTP-response-content-coding(option), + 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), + } + + /// 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), + } + + /// 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), + } + + /// 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; + + /// 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>) -> result; + /// 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; + /// 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) -> 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, 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>; + /// 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>, trailers: future, error-code>>, options: option) -> tuple>>; + /// 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; + /// 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) -> result; + /// Get the HTTP Related Scheme for the Request. When `none`, the + /// implementation may choose an appropriate default scheme. + get-scheme: func() -> option; + /// 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) -> 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; + /// 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) -> 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; + /// 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>) -> tuple, future, 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; + /// 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) -> result<_, request-options-error>; + /// The timeout for receiving the first byte of the Response body. + get-first-byte-timeout: func() -> option; + /// 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) -> result<_, request-options-error>; + /// The timeout for receiving subsequent chunks of bytes in the Response + /// body stream. + get-between-bytes-timeout: func() -> option; + /// 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) -> 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>, trailers: future, error-code>>) -> tuple>>; + /// 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>) -> tuple, future, 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; +} + +/// 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; +} + +/// 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` + /// parameter and returns an `option`. + /// + /// 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` 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>) -> list; +} + +/// 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, 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, 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; + /// 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; + /// 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; + /// 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) -> 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) -> 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, len: u64) -> result; + /// 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, len: u64) -> result; + } +} + +@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, 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; + } + + // 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, TTL-ms: option) -> 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; + } + + // 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) -> 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, keys: list) -> result>, 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) -> result, 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, key-values: list>>) -> 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, keys: list) -> 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, key: key) -> result, 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, key: key, outgoing-value: borrow) -> 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, 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, key: key) -> result; +} \ 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); + + /// 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; + } + /// 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`: + /// 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) -> result<_, error>; + /// Writes the value synchronously. + /// If any other error occurs, it returns an `Err(error)`. + outgoing-value-write-body-sync: func(value: list) -> 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`. + /// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the + /// value as a `stream`. + /// 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, error>; + /// Consumes the value asynchronously and returns the value as a `stream`. + /// If any other error occurs, it returns an `Err(error)`. + incoming-value-consume-async: func() -> result, 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; + } +} 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; +} + +/// 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; + + /// 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; + + /// 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; +} + +/// 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; + + /// 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; + + /// 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; + + @since(version = 0.2.0) + type ipv6-address = tuple; + + @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) -> option; +} + +/// 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, 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: + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + resolve-addresses: func(network: borrow, name: string) -> result; +} + +@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 + /// 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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + start-bind: func(network: borrow, 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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + start-connect: func(network: borrow, remote-address: ip-socket-address) -> result<_, error-code>; + @since(version = 0.2.0) + finish-connect: func() -> result, 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 + /// - + /// - + /// - + /// - + @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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + accept: func() -> 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 `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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + local-address: func() -> result; + /// Get the remote address. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + remote-address: func() -> result; + /// 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; + @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; + @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; + @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; + @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; + @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; + @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; + @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 + /// 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 + /// - + /// - + /// - + /// - + @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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + create-tcp-socket: func(address-family: ip-address-family) -> result; +} + +@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, + /// 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, + /// 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, + } + + /// 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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + start-bind: func(network: borrow, 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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + %stream: func(remote-address: option) -> result, 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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + local-address: func() -> result; + /// 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 + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + remote-address: func() -> result; + /// 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; + @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; + @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; + @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 + /// - + /// - + /// - + /// - + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + receive: func(max-results: u64) -> result, 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; + /// 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 + /// - + /// - + /// - + /// - + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + send: func(datagrams: list) -> result; + /// 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: + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + create-udp-socket: func(address-family: ip-address-family) -> result; +} + +@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), + } + + @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; + + @since(version = 0.3.0) + type ipv6-address = tuple; + + @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 + /// 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 + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + create: static func(address-family: ip-address-family) -> result; + /// 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 + /// - + /// - + /// - + /// - + @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 + /// - + /// - + /// - + /// - + @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 + /// - + /// - + /// - + /// - + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + listen: func() -> result, 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 + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + send: func(data: stream) -> future>; + /// 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 + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + receive: func() -> tuple, future>>; + /// 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 + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + get-local-address: func() -> result; + /// Get the remote address. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + get-remote-address: func() -> result; + /// 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; + @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; + @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; + @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; + @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; + @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; + @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; + @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: + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + create: static func(address-family: ip-address-family) -> result; + /// 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 + /// - + /// - + /// - + /// - + @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 + /// - + /// - + /// - + /// - + @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 + /// - + /// - + /// - + /// - + @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 + /// - + /// - + /// - + /// - + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + send: async func(data: list, remote-address: option) -> 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 + /// - + /// - + /// - + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + receive: async func() -> result, 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 + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + get-local-address: func() -> result; + /// 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 + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + get-remote-address: func() -> result; + /// 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; + @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; + @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; + @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), + } + + /// 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: + /// - + /// - + /// - + /// - + @since(version = 0.3.0) + resolve-addresses: async func(name: string) -> result, 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..d6ad9109d4 --- /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.6.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; +} diff --git a/sdks/moonbit/golem_sdk/interface/golem/api/oplog/pkg.generated.mbti b/sdks/moonbit/golem_sdk/interface/golem/api/oplog/pkg.generated.mbti index 07bda70eb8..f9aafe3495 100644 --- a/sdks/moonbit/golem_sdk/interface/golem/api/oplog/pkg.generated.mbti +++ b/sdks/moonbit/golem_sdk/interface/golem/api/oplog/pkg.generated.mbti @@ -175,6 +175,11 @@ pub(all) struct CompletionDeliveredParameters { start_index : UInt64 } derive(Eq, Show) +pub(all) struct CompletionDeliveredParameters { + timestamp : @system-clock.Instant + start_index : UInt64 +} derive(Eq, Show) + pub(all) struct CompletionDiscardedParameters { timestamp : @system-clock.Instant start_index : UInt64 diff --git a/test-components/agent-sdk-go/.gitignore b/test-components/agent-sdk-go/.gitignore new file mode 100644 index 0000000000..c4a1b437a0 --- /dev/null +++ b/test-components/agent-sdk-go/.gitignore @@ -0,0 +1 @@ +/golem-temp diff --git a/test-components/agent-sdk-go/golem.yaml b/test-components/agent-sdk-go/golem.yaml new file mode 100644 index 0000000000..5e99833879 --- /dev/null +++ b/test-components/agent-sdk-go/golem.yaml @@ -0,0 +1,19 @@ +manifestVersion: 1.6.0 + +app: agent-sdk-go + +includes: +- ../golem-test-components-common.yaml + +components: + golem-it:agent-sdk-go: + dir: "module" + templates: go, go-test-component + +environments: + local: + server: local + componentPresets: release + cloud: + server: cloud + componentPresets: release diff --git a/test-components/agent-sdk-go/module/agents/blobs/blobs.go b/test-components/agent-sdk-go/module/agents/blobs/blobs.go new file mode 100644 index 0000000000..012a4d0b09 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/blobs/blobs.go @@ -0,0 +1,39 @@ +// Package blobs is the DEFINITION of the agent exercising the SDK's blobstore +// wrapper (golem/blobstore). Behaviour lives in blobs/impl. +package blobs + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type WriteIn struct { + Container string + Object string + Data string +} + +type ObjectIn struct { + Container string + Object string +} + +type ContainerIn struct{ Container string } + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "BlobAgent", Description: "Exercises the Go SDK blobstore wrapper", Mode: golem.Durable, +}) + +var ( + Write = golem.DefineMethod[Id, WriteIn, golem.Unit]("write", + golem.Desc("Write an object into a container, creating the container if needed")) + // Read returns the object's content, or "" when the object is absent. + Read = golem.DefineMethod[Id, ObjectIn, string]("read", + golem.Desc("Read an object; empty string when absent")) + Size = golem.DefineMethod[Id, ObjectIn, int64]("size", + golem.Desc("Return the object's size in bytes")) + Delete = golem.DefineMethod[Id, ObjectIn, golem.Unit]("delete", + golem.Desc("Delete an object")) + // List returns the container's object names, sorted so the result is comparable. + List = golem.DefineMethod[Id, ContainerIn, []string]("list", + golem.Desc("List a container's objects, sorted")) +) diff --git a/test-components/agent-sdk-go/module/agents/blobs/impl/impl.go b/test-components/agent-sdk-go/module/agents/blobs/impl/impl.go new file mode 100644 index 0000000000..0e8116706a --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/blobs/impl/impl.go @@ -0,0 +1,49 @@ +// Package impl is the IMPLEMENTATION of the blobstore agent. Each handler is a +// thin call into the SDK's blobstore wrapper, so the executor tests exercise the +// wrapper end to end. +package impl + +import ( + "sort" + + "agent-sdk-go/agents/blobs" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/blobstore" +) + +type state struct{} + +var agent = golem.Implement(blobs.Agent, func(blobs.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, blobs.Write, func(_ *golem.Context[state], in blobs.WriteIn) golem.Unit { + c := golem.Must(blobstore.GetOrCreateContainer(in.Container)) + golem.Must0(c.WriteData(in.Object, []byte(in.Data))) + return golem.Unit{} + }) + golem.Handle(agent, blobs.Read, func(_ *golem.Context[state], in blobs.ObjectIn) string { + c := golem.Must(blobstore.GetOrCreateContainer(in.Container)) + data, found := golem.Must2(c.GetData(in.Object)) + if !found { + return "" + } + return string(data) + }) + golem.Handle(agent, blobs.Size, func(_ *golem.Context[state], in blobs.ObjectIn) int64 { + c := golem.Must(blobstore.GetOrCreateContainer(in.Container)) + info := golem.Must(c.ObjectInfo(in.Object)) + return int64(info.Size) + }) + golem.Handle(agent, blobs.Delete, func(_ *golem.Context[state], in blobs.ObjectIn) golem.Unit { + c := golem.Must(blobstore.GetOrCreateContainer(in.Container)) + golem.Must0(c.Delete(in.Object)) + return golem.Unit{} + }) + golem.Handle(agent, blobs.List, func(_ *golem.Context[state], in blobs.ContainerIn) []string { + c := golem.Must(blobstore.GetOrCreateContainer(in.Container)) + names := golem.Must(c.ListObjects()) + sort.Strings(names) // deterministic order for the test assertion + return names + }) +} diff --git a/test-components/agent-sdk-go/module/agents/clock/clock.go b/test-components/agent-sdk-go/module/agents/clock/clock.go new file mode 100644 index 0000000000..a71a20cb37 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/clock/clock.go @@ -0,0 +1,20 @@ +// Package clock is the DEFINITION of the durable-clock test agent. It records +// wall-clock readings into durable state so a replay after an executor restart +// can be shown to reproduce the exact recorded time rather than reading the +// clock afresh. Behaviour lives in clock/impl. +package clock + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "ClockAgent", Description: "Durable wall-clock readings for replay tests", Mode: golem.Durable, +}) + +var ( + RecordTime = golem.DefineMethod[Id, golem.Unit, int64]("record-time", + golem.Desc("Read time.Now() into durable state and return it as unix nanos")) + FirstTime = golem.DefineMethod[Id, golem.Unit, int64]("first-time", + golem.Desc("Return the first recorded reading as unix nanos")) +) diff --git a/test-components/agent-sdk-go/module/agents/clock/impl/impl.go b/test-components/agent-sdk-go/module/agents/clock/impl/impl.go new file mode 100644 index 0000000000..2c349b6b02 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/clock/impl/impl.go @@ -0,0 +1,29 @@ +// Package impl is the IMPLEMENTATION of the durable-clock agent. time.Now() is +// routed through the durable host clock, so a reading recorded in one invocation +// is reproduced from the oplog when that invocation is replayed after a restart +// (rather than re-reading the current time). The replay test asserts this by +// checking the first recorded reading is unchanged across an executor restart. +package impl + +import ( + "time" + + "agent-sdk-go/agents/clock" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ times []int64 } + +var agent = golem.Implement(clock.Agent, func(clock.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, clock.RecordTime, func(ctx *golem.Context[state], _ golem.Unit) int64 { + now := time.Now().UnixNano() + ctx.State.times = append(ctx.State.times, now) + return now + }) + golem.Handle(agent, clock.FirstTime, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.times[0] + }) +} diff --git a/test-components/agent-sdk-go/module/agents/configecho/configecho.go b/test-components/agent-sdk-go/module/agents/configecho/configecho.go new file mode 100644 index 0000000000..96498993e5 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/configecho/configecho.go @@ -0,0 +1,27 @@ +// Package configecho is the DEFINITION of the configured echo agent. The +// behaviour lives in configecho/impl. +package configecho + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type FeeConfig struct{ Cents int64 } + +// Config flattens to per-key paths (field names lower-cased): Greeting -> "greeting", +// Fee.Cents -> "fee"/"cents". +type Config struct { + Greeting string + Fee FeeConfig +} + +var Agent = golem.DefineConfiguredAgent[Id, Config](golem.Spec{ + Name: "ConfigAgent", Description: "Echoes agent config at runtime", Mode: golem.Durable, +}) + +var ( + Greeting = golem.DefineMethod[Id, golem.Unit, string]("greeting", + golem.Desc("Return the configured greeting")) + Cents = golem.DefineMethod[Id, golem.Unit, int64]("cents", + golem.Desc("Return the configured fee (nested config path)")) +) diff --git a/test-components/agent-sdk-go/module/agents/configecho/impl/impl.go b/test-components/agent-sdk-go/module/agents/configecho/impl/impl.go new file mode 100644 index 0000000000..c70b5008a7 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/configecho/impl/impl.go @@ -0,0 +1,23 @@ +// Package impl is the IMPLEMENTATION of the configured echo agent: +// its methods read the agent config with golem.Config. Its constructor doesn't +// need config, so it uses plain Implement. Importing it registers the agent. +package impl + +import ( + "agent-sdk-go/agents/configecho" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(configecho.Agent, func(configecho.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, configecho.Greeting, func(ctx *golem.Context[state], _ golem.Unit) string { + return golem.Config(configecho.Agent, ctx).Greeting + }) + golem.Handle(agent, configecho.Cents, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return golem.Config(configecho.Agent, ctx).Fee.Cents + }) +} diff --git a/test-components/agent-sdk-go/module/agents/counter/counter.go b/test-components/agent-sdk-go/module/agents/counter/counter.go new file mode 100644 index 0000000000..fd42717471 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/counter/counter.go @@ -0,0 +1,27 @@ +// Package counter is the DEFINITION of the durable counter agent: its +// identity, method descriptors, and input/output types. Other agents import this +// package to call the counter; the behaviour and state live in counter/impl. +package counter + +import "github.com/golemcloud/golem/sdks/go/golem" + +// CounterID holds the constructor parameters and the type-level identity. +type CounterID struct{ Name string } + +// AddIn is the parameter list for add. +type AddIn struct{ By int64 } + +var Agent = golem.DefineAgent[CounterID](golem.Spec{ + Name: "CounterAgent", + Description: "A durable counter for the Go SDK runtime tests", + Mode: golem.Durable, +}) + +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")) +) diff --git a/test-components/agent-sdk-go/module/agents/counter/impl/impl.go b/test-components/agent-sdk-go/module/agents/counter/impl/impl.go new file mode 100644 index 0000000000..40595ea7a5 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/counter/impl/impl.go @@ -0,0 +1,27 @@ +// Package impl is the IMPLEMENTATION of the counter agent: its +// private state and method handlers. Importing it registers the agent. +package impl + +import ( + "agent-sdk-go/agents/counter" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ value int64 } + +func (s *state) current() int64 { return s.value } + +var agent = golem.Implement(counter.Agent, func(counter.CounterID) *state { return &state{} }) + +func init() { + golem.Handle(agent, counter.Increment, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.value++ + return ctx.State.value + }) + golem.Handle(agent, counter.Add, func(ctx *golem.Context[state], in counter.AddIn) int64 { + ctx.State.value += in.By + return ctx.State.value + }) + golem.Handle(agent, counter.Value, golem.Bind0((*state).current)) // method-expression binding +} diff --git a/test-components/agent-sdk-go/module/agents/customdur/customdur.go b/test-components/agent-sdk-go/module/agents/customdur/customdur.go new file mode 100644 index 0000000000..915356f81c --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/customdur/customdur.go @@ -0,0 +1,18 @@ +// Package customdur is the DEFINITION of an agent that exercises the custom +// durability API (golem.DurableOp): it wraps an outbound HTTP side effect so the +// operation is recorded once and replayed from the oplog after a restart rather +// than re-run. Behaviour lives in customdur/impl. +package customdur + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type CallbackIn struct{ Payload string } + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "CustomDurAgent", Description: "Custom durable operation (DurableOp) for replay tests", Mode: golem.Durable, +}) + +var Callback = golem.DefineMethod[Id, CallbackIn, string]("callback", + golem.Desc("Wrap an outbound HTTP call in golem.DurableOp and return its body")) diff --git a/test-components/agent-sdk-go/module/agents/customdur/impl/impl.go b/test-components/agent-sdk-go/module/agents/customdur/impl/impl.go new file mode 100644 index 0000000000..d21df8e795 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/customdur/impl/impl.go @@ -0,0 +1,35 @@ +// Package impl is the IMPLEMENTATION of the custom-durability agent. The handler +// wraps a raw outbound HTTP call in golem.DurableOp, so the call's result is +// recorded once and, after an executor restart, replayed from the oplog without +// re-running the body — the replay test asserts the external counter advances +// once per live call, not on replay. +package impl + +import ( + "io" + "net/http" + "os" + + "agent-sdk-go/agents/customdur" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(customdur.Agent, func(customdur.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, customdur.Callback, func(_ *golem.Context[state], in customdur.CallbackIn) string { + return golem.DurableOp( + golem.DurableSpec{Interface: "agent-sdk-go", Function: "custom-callback", Type: golem.WriteRemote}, + in, + func() string { + url := "http://localhost:" + os.Getenv("PORT") + "/callback?payload=" + in.Payload + resp := golem.Must(http.Get(url)) + defer resp.Body.Close() + return string(golem.Must(io.ReadAll(resp.Body))) + }, + ) + }) +} diff --git a/test-components/agent-sdk-go/module/agents/httpcall/httpcall.go b/test-components/agent-sdk-go/module/agents/httpcall/httpcall.go new file mode 100644 index 0000000000..14bfd56545 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/httpcall/httpcall.go @@ -0,0 +1,25 @@ +// Package httpcall is the DEFINITION of the durable outbound-HTTP agent used +// by the replay tests. The behaviour lives in httpcall/impl. +package httpcall + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type CallbackIn struct{ Payload string } + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "HttpAgent", Description: "Durable outbound HTTP for replay tests", Mode: golem.Durable, +}) + +var Callback = golem.DefineMethod[Id, CallbackIn, string]("callback", + golem.Desc("GET the PORT callback endpoint with the payload and return its body")) + +// RetryCallback calls a flaky endpoint under a status-code retry policy. +var RetryCallback = golem.DefineMethod[Id, CallbackIn, string]("retry-callback", + golem.Desc("GET the flaky endpoint under a retry policy that retries on 500")) + +// AtomicCallback makes the same call inside golem.Atomically — the minimal case +// for "does an outbound HTTP call settle before an atomic region closes?". +var AtomicCallback = golem.DefineMethod[Id, CallbackIn, string]("atomic-callback", + golem.Desc("GET the callback endpoint inside an atomic region")) diff --git a/test-components/agent-sdk-go/module/agents/httpcall/impl/impl.go b/test-components/agent-sdk-go/module/agents/httpcall/impl/impl.go new file mode 100644 index 0000000000..ebe5252f70 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/httpcall/impl/impl.go @@ -0,0 +1,45 @@ +// Package impl is the IMPLEMENTATION of the outbound-HTTP agent. The +// SDK routes net/http through the durable wasi:http transport, so the response is +// recorded in the oplog and served from it on replay after a restart rather than +// re-fetched (the exactly-once test asserts this via an external counter). +package impl + +import ( + "io" + "net/http" + "os" + + "agent-sdk-go/agents/httpcall" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/retry" +) + +type state struct{} + +func fetch(payload string) string { + url := "http://localhost:" + os.Getenv("PORT") + "/callback?payload=" + payload + resp := golem.Must(http.Get(url)) + defer resp.Body.Close() + return string(golem.Must(io.ReadAll(resp.Body))) +} + +var agent = golem.Implement(httpcall.Agent, func(httpcall.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, httpcall.Callback, func(_ *golem.Context[state], in httpcall.CallbackIn) string { + return fetch(in.Payload) + }) + golem.Handle(agent, httpcall.RetryCallback, func(_ *golem.Context[state], in httpcall.CallbackIn) string { + // Retry the request while the endpoint answers 500; the host re-issues it + // transparently, so the handler just sees the eventual success. + pol := retry.Immediate().MaxRetries(10).OnlyWhen(retry.StatusCode.OneOf(500)) + defer retry.With(retry.Named("flaky-endpoint", pol).WithPriority(10))() + return fetch(in.Payload) + }) + golem.Handle(agent, httpcall.AtomicCallback, func(_ *golem.Context[state], in httpcall.CallbackIn) string { + var body string + golem.Atomically(func() { body = fetch(in.Payload) }) + return body + }) +} diff --git a/test-components/agent-sdk-go/module/agents/kvstore/impl/impl.go b/test-components/agent-sdk-go/module/agents/kvstore/impl/impl.go new file mode 100644 index 0000000000..d23c57b0fc --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/kvstore/impl/impl.go @@ -0,0 +1,49 @@ +// Package impl is the IMPLEMENTATION of the keyvalue agent. Each handler is a +// thin call into the SDK's keyvalue wrapper, so the executor tests exercise the +// wrapper end to end (including its durability: a key written in one invocation +// is still readable after a crash, replayed from the oplog). +package impl + +import ( + "sort" + + "agent-sdk-go/agents/kvstore" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/keyvalue" +) + +type state struct{} + +var agent = golem.Implement(kvstore.Agent, func(kvstore.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, kvstore.Set, func(_ *golem.Context[state], in kvstore.SetIn) golem.Unit { + b := golem.Must(keyvalue.OpenBucket(in.Bucket)) + golem.Must0(b.Set(in.Key, []byte(in.Value))) + return golem.Unit{} + }) + golem.Handle(agent, kvstore.Get, func(_ *golem.Context[state], in kvstore.GetIn) string { + b := golem.Must(keyvalue.OpenBucket(in.Bucket)) + value, found := golem.Must2(b.Get(in.Key)) + if !found { + return "" + } + return string(value) + }) + golem.Handle(agent, kvstore.Exists, func(_ *golem.Context[state], in kvstore.GetIn) bool { + b := golem.Must(keyvalue.OpenBucket(in.Bucket)) + return golem.Must(b.Exists(in.Key)) + }) + golem.Handle(agent, kvstore.Delete, func(_ *golem.Context[state], in kvstore.GetIn) golem.Unit { + b := golem.Must(keyvalue.OpenBucket(in.Bucket)) + golem.Must0(b.Delete(in.Key)) + return golem.Unit{} + }) + golem.Handle(agent, kvstore.Keys, func(_ *golem.Context[state], in kvstore.GetIn) []string { + b := golem.Must(keyvalue.OpenBucket(in.Bucket)) + keys := golem.Must(b.Keys()) + sort.Strings(keys) // deterministic order for the test assertion + return keys + }) +} diff --git a/test-components/agent-sdk-go/module/agents/kvstore/kvstore.go b/test-components/agent-sdk-go/module/agents/kvstore/kvstore.go new file mode 100644 index 0000000000..f0169c85f0 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/kvstore/kvstore.go @@ -0,0 +1,37 @@ +// Package kvstore is the DEFINITION of the agent exercising the SDK's keyvalue +// wrapper (golem/keyvalue). Behaviour lives in kvstore/impl. +package kvstore + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type SetIn struct { + Bucket string + Key string + Value string +} + +type GetIn struct { + Bucket string + Key string +} + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "KvAgent", Description: "Exercises the Go SDK keyvalue wrapper", Mode: golem.Durable, +}) + +var ( + Set = golem.DefineMethod[Id, SetIn, golem.Unit]("set", + golem.Desc("Store a string value under a key")) + // Get returns the stored value, or "" when the key is absent. + Get = golem.DefineMethod[Id, GetIn, string]("get", + golem.Desc("Read a key; empty string when absent")) + Exists = golem.DefineMethod[Id, GetIn, bool]("exists", + golem.Desc("Report whether a key is present")) + Delete = golem.DefineMethod[Id, GetIn, golem.Unit]("delete", + golem.Desc("Delete a key")) + // Keys returns the bucket's keys, sorted so the result is comparable. + Keys = golem.DefineMethod[Id, GetIn, []string]("keys", + golem.Desc("List the bucket's keys, sorted")) +) diff --git a/test-components/agent-sdk-go/module/agents/ledger/impl/impl.go b/test-components/agent-sdk-go/module/agents/ledger/impl/impl.go new file mode 100644 index 0000000000..8fbd1882cf --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/ledger/impl/impl.go @@ -0,0 +1,23 @@ +// Package impl is the IMPLEMENTATION of the ledger agent. +package impl + +import ( + "agent-sdk-go/agents/ledger" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ total int64 } + +var agent = golem.Implement(ledger.Agent, func(ledger.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, ledger.Record, func(ctx *golem.Context[state], in ledger.RecordIn) golem.Result[int64, string] { + if in.Amount < 0 { + return golem.Err[int64, string]("cannot record a negative amount") + } + ctx.State.total += in.Amount + return golem.Ok[int64, string](ctx.State.total) + }) + golem.Handle(agent, ledger.Total, func(ctx *golem.Context[state], _ golem.Unit) int64 { return ctx.State.total }) +} diff --git a/test-components/agent-sdk-go/module/agents/ledger/ledger.go b/test-components/agent-sdk-go/module/agents/ledger/ledger.go new file mode 100644 index 0000000000..6a04ed7521 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/ledger/ledger.go @@ -0,0 +1,19 @@ +// Package ledger is the DEFINITION of the per-region ledger agent (the RPC +// callee). The behaviour and state live in ledger/impl. +package ledger + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Region string } + +type RecordIn struct{ Amount int64 } + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "LedgerAgent", Description: "Per-region revenue ledger", Mode: golem.Durable, +}) + +var ( + Record = golem.DefineMethod[Id, RecordIn, golem.Result[int64, string]]("record", + golem.Desc("Add to the ledger, returning the new total or an error value")) + Total = golem.DefineMethod[Id, golem.Unit, int64]("total") +) diff --git a/test-components/agent-sdk-go/module/agents/promises/impl/impl.go b/test-components/agent-sdk-go/module/agents/promises/impl/impl.go new file mode 100644 index 0000000000..01e574028c --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/promises/impl/impl.go @@ -0,0 +1,46 @@ +// Package impl is the IMPLEMENTATION of the promise agent. Create mints a +// promise and keeps the handle in state, returning its oplog index so an external +// completer (the executor's complete-promise API, or another agent) can address +// it; Await suspends the worker until that promise is completed. +package impl + +import ( + "fmt" + + "agent-sdk-go/agents/promises" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +// state keeps the created promises by oplog index, so Await can pick the one the +// caller names without having to rebuild a PromiseID from parts. +type state struct { + created map[uint64]*golem.Promise[string] +} + +var agent = golem.Implement(promises.Agent, func(promises.Id) *state { + return &state{created: map[uint64]*golem.Promise[string]{}} +}) + +func init() { + golem.Handle(agent, promises.Create, func(ctx *golem.Context[state], _ golem.Unit) int64 { + p := golem.NewPromise[string]() + id := p.ID() + ctx.State.created[id.OplogIndex] = p + return int64(id.OplogIndex) + }) + golem.Handle(agent, promises.Await, func(ctx *golem.Context[state], in promises.OplogIdxIn) string { + p := ctx.State.created[uint64(in.OplogIdx)] + if p == nil { + panic(fmt.Errorf("no promise created with oplog index %d", in.OplogIdx)) + } + return p.Await() // suspends until completed + }) + golem.Handle(agent, promises.Complete, func(ctx *golem.Context[state], in promises.CompleteIn) bool { + p := ctx.State.created[uint64(in.OplogIdx)] + if p == nil { + panic(fmt.Errorf("no promise created with oplog index %d", in.OplogIdx)) + } + return golem.CompletePromise(p.ID(), in.Value) + }) +} diff --git a/test-components/agent-sdk-go/module/agents/promises/promises.go b/test-components/agent-sdk-go/module/agents/promises/promises.go new file mode 100644 index 0000000000..2a6b08f6ab --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/promises/promises.go @@ -0,0 +1,33 @@ +// Package promises is the DEFINITION of the agent exercising the SDK's promise +// wrapper (golem.NewPromise / Await / CompletePromise). Behaviour lives in +// promises/impl. +package promises + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type OplogIdxIn struct{ OplogIdx int64 } + +type CompleteIn struct { + OplogIdx int64 + Value string +} + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "PromiseAgent", Description: "Exercises the Go SDK promise wrapper", Mode: golem.Durable, +}) + +var ( + // Create makes a promise and returns its oplog index — the part of the + // PromiseID a completer needs alongside this agent's own id. + Create = golem.DefineMethod[Id, golem.Unit, int64]("create", + golem.Desc("Create a promise and return its oplog index")) + // Await suspends until the promise is completed and returns its payload. + Await = golem.DefineMethod[Id, OplogIdxIn, string]("await", + golem.Desc("Await the promise with the given oplog index")) + // Complete completes a promise from inside the agent (the agent-to-agent path), + // reporting whether this call was the one that completed it. + Complete = golem.DefineMethod[Id, CompleteIn, bool]("complete", + golem.Desc("Complete the promise with the given oplog index")) +) diff --git a/test-components/agent-sdk-go/module/agents/richtypes/impl/impl.go b/test-components/agent-sdk-go/module/agents/richtypes/impl/impl.go new file mode 100644 index 0000000000..4f50f513f4 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/richtypes/impl/impl.go @@ -0,0 +1,32 @@ +// Package impl is the IMPLEMENTATION of the composite-types agent. +package impl + +import ( + "fmt" + "strings" + + "agent-sdk-go/agents/richtypes" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(richtypes.Agent, func(richtypes.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, richtypes.Describe, func(_ *golem.Context[state], in richtypes.DescribeIn) string { + note := "none" + if in.Note != nil { + note = *in.Note + } + return fmt.Sprintf("tags=%s note=%s", strings.Join(in.Tags, ","), note) + }) + golem.Handle(agent, richtypes.Repeat, func(_ *golem.Context[state], in richtypes.RepeatIn) []string { + out := make([]string, 0, in.N) + for i := int64(0); i < in.N; i++ { + out = append(out, in.S) + } + return out + }) +} diff --git a/test-components/agent-sdk-go/module/agents/richtypes/richtypes.go b/test-components/agent-sdk-go/module/agents/richtypes/richtypes.go new file mode 100644 index 0000000000..06123b8343 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/richtypes/richtypes.go @@ -0,0 +1,30 @@ +// Package richtypes is the DEFINITION of the composite-types agent. The +// behaviour lives in richtypes/impl. +package richtypes + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +// DescribeIn flattens to two params: a list and an option. +type DescribeIn struct { + Tags []string + Note *string +} + +// RepeatIn flattens to a string and an s64. +type RepeatIn struct { + S string + N int64 +} + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "RichAgent", Description: "Composite type round-trips", Mode: golem.Durable, +}) + +var ( + Describe = golem.DefineMethod[Id, DescribeIn, string]("describe", + golem.Desc("Summarize a list + optional argument")) + Repeat = golem.DefineMethod[Id, RepeatIn, []string]("repeat", + golem.Desc("Return a list of N copies of S")) +) diff --git a/test-components/agent-sdk-go/module/agents/rpccaller/impl/impl.go b/test-components/agent-sdk-go/module/agents/rpccaller/impl/impl.go new file mode 100644 index 0000000000..e728021581 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/rpccaller/impl/impl.go @@ -0,0 +1,36 @@ +// Package impl is the IMPLEMENTATION of the RPC caller: it invokes +// the ledger agent via typed cross-agent RPC (synchronous Call and async +// CallAsync + Future.Get), unwrapping the ledger's Result with MustOk. Importing +// only ledger (the callee's DEFINITION) keeps the two impls free of an +// import cycle. +package impl + +import ( + "agent-sdk-go/agents/ledger" + "agent-sdk-go/agents/rpccaller" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(rpccaller.Agent, func(rpccaller.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, rpccaller.Call, func(_ *golem.Context[state], in rpccaller.CallIn) int64 { + c := ledger.Agent.Get(ledger.Id{Region: in.Region}) + return ledger.Record.Call(c, ledger.RecordIn{Amount: in.Amount}).MustOk() + }) + golem.Handle(agent, rpccaller.AtomicCall, func(_ *golem.Context[state], in rpccaller.CallIn) int64 { + var total int64 + golem.Atomically(func() { + c := ledger.Agent.Get(ledger.Id{Region: in.Region}) + total = ledger.Record.Call(c, ledger.RecordIn{Amount: in.Amount}).MustOk() + }) + return total + }) + golem.Handle(agent, rpccaller.Async, func(_ *golem.Context[state], in rpccaller.CallIn) int64 { + c := ledger.Agent.Get(ledger.Id{Region: in.Region}) + return ledger.Record.CallAsync(c, ledger.RecordIn{Amount: in.Amount}).Get().MustOk() + }) +} diff --git a/test-components/agent-sdk-go/module/agents/rpccaller/rpccaller.go b/test-components/agent-sdk-go/module/agents/rpccaller/rpccaller.go new file mode 100644 index 0000000000..6cfdf80332 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/rpccaller/rpccaller.go @@ -0,0 +1,27 @@ +// Package rpccaller is the DEFINITION of the cross-agent RPC caller. The +// behaviour lives in rpccaller/impl. +package rpccaller + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type CallIn struct { + Region string + Amount int64 +} + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "RpcAgent", Description: "Cross-agent RPC caller", Mode: golem.Durable, +}) + +var ( + Call = golem.DefineMethod[Id, CallIn, int64]("call", + golem.Desc("Record via a synchronous RPC and return the ledger's new total")) + Async = golem.DefineMethod[Id, CallIn, int64]("async", + golem.Desc("Record via CallAsync + Future.Get and return the ledger's new total")) + // AtomicCall makes the same RPC inside golem.Atomically — checks whether a + // cross-agent call settles before an atomic region closes. + AtomicCall = golem.DefineMethod[Id, CallIn, int64]("atomic-call", + golem.Desc("Record via a synchronous RPC inside an atomic region")) +) diff --git a/test-components/agent-sdk-go/module/agents/saga/impl/impl.go b/test-components/agent-sdk-go/module/agents/saga/impl/impl.go new file mode 100644 index 0000000000..cfb4186b67 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/saga/impl/impl.go @@ -0,0 +1,67 @@ +// Package impl is the IMPLEMENTATION of the saga agent. Each step and each +// compensation appends its name to the agent's state, so a caller can read back +// exactly what ran and in what order: a committed run records only the forward +// steps, while a rolled-back run also records the compensations of the steps that +// had already succeeded, in reverse order. +package impl + +import ( + "agent-sdk-go/agents/saga" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ log []string } + +var agent = golem.Implement(saga.Agent, func(saga.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, saga.Run, func(ctx *golem.Context[state], in saga.RunIn) string { + s := ctx.State + record := func(name string) { s.log = append(s.log, name) } + + // charge succeeds and knows how to undo itself (refund). + charge := golem.NewOperation( + func(_ golem.Unit) golem.Result[string, string] { + record("charge") + return golem.Ok[string, string]("charged") + }, + func(_ golem.Unit, _ string) golem.Result[golem.Unit, string] { + record("refund") + return golem.Ok[golem.Unit, string](golem.Unit{}) + }, + ) + // ship records its attempt, then fails when the caller asked it to. + ship := golem.NewOperation( + func(fail bool) golem.Result[string, string] { + record("ship") + if fail { + return golem.Err[string, string]("ship failed") + } + return golem.Ok[string, string]("shipped") + }, + func(bool, string) golem.Result[golem.Unit, string] { + record("unship") + return golem.Ok[golem.Unit, string](golem.Unit{}) + }, + ) + + res := golem.FallibleTransaction(func(tx *golem.Transaction[string]) golem.Result[string, string] { + if r := golem.Step(tx, charge, golem.Unit{}); r.IsErr() { + return golem.Err[string, string](r.Err()) + } + if r := golem.Step(tx, ship, in.Fail); r.IsErr() { + return golem.Err[string, string](r.Err()) + } + return golem.Ok[string, string]("committed") + }) + + if res.IsErr() { + return "rolled-back" + } + return res.Ok() + }) + golem.Handle(agent, saga.Log, func(ctx *golem.Context[state], _ golem.Unit) []string { + return ctx.State.log + }) +} diff --git a/test-components/agent-sdk-go/module/agents/saga/saga.go b/test-components/agent-sdk-go/module/agents/saga/saga.go new file mode 100644 index 0000000000..e0ffa7027b --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/saga/saga.go @@ -0,0 +1,27 @@ +// Package saga is the DEFINITION of the agent exercising the SDK's transaction +// (saga) helpers. Behaviour lives in saga/impl. +package saga + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type RunIn struct { + // Fail makes the second step return an error, which rolls the transaction + // back and runs the first step's compensation. + Fail bool +} + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "SagaAgent", Description: "Exercises the Go SDK transaction (saga) helpers", Mode: golem.Durable, +}) + +var ( + // Run executes a two-step transaction, recording each step and compensation + // in state. It returns "committed" or "rolled-back". + Run = golem.DefineMethod[Id, RunIn, string]("run", + golem.Desc("Run a two-step saga; roll back when Fail is set")) + // Log returns the recorded step/compensation names in order. + Log = golem.DefineMethod[Id, golem.Unit, []string]("log", + golem.Desc("Return the recorded step and compensation names")) +) diff --git a/test-components/agent-sdk-go/module/agents/scheduler/impl/impl.go b/test-components/agent-sdk-go/module/agents/scheduler/impl/impl.go new file mode 100644 index 0000000000..5350c97a35 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/scheduler/impl/impl.go @@ -0,0 +1,35 @@ +// Package impl is the IMPLEMENTATION of the scheduler agent. It schedules a +// cross-agent invocation for a moment in the future; the executor runs it without +// the caller waiting, so the tests observe the effect by polling the target +// counter. Cancelling the returned handle must prevent the invocation entirely. +package impl + +import ( + "time" + + "agent-sdk-go/agents/counter" + "agent-sdk-go/agents/scheduler" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{} + +var agent = golem.Implement(scheduler.Agent, func(scheduler.Id) *state { return &state{} }) + +func scheduleBump(in scheduler.ScheduleIn) *golem.ScheduledInvocation { + c := counter.Agent.Get(counter.CounterID{Name: in.Target}) + at := time.Now().Add(time.Duration(in.DelayMillis) * time.Millisecond) + return counter.Increment.Schedule(c, at, golem.Unit{}) +} + +func init() { + golem.Handle(agent, scheduler.Bump, func(_ *golem.Context[state], in scheduler.ScheduleIn) golem.Unit { + scheduleBump(in) + return golem.Unit{} + }) + golem.Handle(agent, scheduler.BumpCancelled, func(_ *golem.Context[state], in scheduler.ScheduleIn) golem.Unit { + scheduleBump(in).Cancel() + return golem.Unit{} + }) +} diff --git a/test-components/agent-sdk-go/module/agents/scheduler/scheduler.go b/test-components/agent-sdk-go/module/agents/scheduler/scheduler.go new file mode 100644 index 0000000000..a21b845684 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/scheduler/scheduler.go @@ -0,0 +1,29 @@ +// Package scheduler is the DEFINITION of the agent exercising scheduled +// invocations (MethodDef.Schedule + ScheduledInvocation.Cancel). Behaviour lives +// in scheduler/impl. +package scheduler + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type ScheduleIn struct { + // Target names the counter agent instance to bump. + Target string + // DelayMillis is how far in the future to schedule the bump. + DelayMillis int64 +} + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "SchedulerAgent", Description: "Exercises scheduled invocations", Mode: golem.Durable, +}) + +var ( + // Bump schedules a counter increment and lets it run. + Bump = golem.DefineMethod[Id, ScheduleIn, golem.Unit]("bump", + golem.Desc("Schedule an increment on the target counter")) + // BumpCancelled schedules the same increment and immediately cancels it, so + // the counter must never move. + BumpCancelled = golem.DefineMethod[Id, ScheduleIn, golem.Unit]("bump-cancelled", + golem.Desc("Schedule an increment on the target counter, then cancel it")) +) diff --git a/test-components/agent-sdk-go/module/agents/snapstate/impl/impl.go b/test-components/agent-sdk-go/module/agents/snapstate/impl/impl.go new file mode 100644 index 0000000000..990dbe3038 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/snapstate/impl/impl.go @@ -0,0 +1,31 @@ +// Package impl is the IMPLEMENTATION of the custom-snapshot agent. The counter +// is deliberately an UNEXPORTED field, which the SDK's default reflective JSON +// snapshot cannot see — so the state survives snapshot-based recovery only if the +// SDK actually calls this type's Save/Load (the golem.Snapshotter path). +package impl + +import ( + "encoding/json" + + "agent-sdk-go/agents/snapstate" + + "github.com/golemcloud/golem/sdks/go/golem" +) + +type state struct{ count int64 } + +// Save/Load implement golem.Snapshotter over the unexported counter. +func (s *state) Save() ([]byte, error) { return json.Marshal(s.count) } +func (s *state) Load(b []byte) error { return json.Unmarshal(b, &s.count) } + +var agent = golem.Implement(snapstate.Agent, func(snapstate.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, snapstate.Bump, func(ctx *golem.Context[state], _ golem.Unit) int64 { + ctx.State.count++ + return ctx.State.count + }) + golem.Handle(agent, snapstate.Value, func(ctx *golem.Context[state], _ golem.Unit) int64 { + return ctx.State.count + }) +} diff --git a/test-components/agent-sdk-go/module/agents/snapstate/snapstate.go b/test-components/agent-sdk-go/module/agents/snapstate/snapstate.go new file mode 100644 index 0000000000..e084f9bc7c --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/snapstate/snapstate.go @@ -0,0 +1,21 @@ +// Package snapstate is the DEFINITION of the agent exercising the SDK's custom +// snapshot support (golem.Snapshotter). Behaviour lives in snapstate/impl. +package snapstate + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "SnapAgent", + Description: "Exercises the Go SDK custom snapshot (Snapshotter)", + Mode: golem.Durable, + Snapshot: golem.SnapshotEveryN(2), +}) + +var ( + Bump = golem.DefineMethod[Id, golem.Unit, int64]("bump", + golem.Desc("Increase the counter and return it")) + Value = golem.DefineMethod[Id, golem.Unit, int64]("value", + golem.Desc("Return the current counter")) +) diff --git a/test-components/agent-sdk-go/module/agents/wsecho/impl/impl.go b/test-components/agent-sdk-go/module/agents/wsecho/impl/impl.go new file mode 100644 index 0000000000..6f6e28a80d --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/wsecho/impl/impl.go @@ -0,0 +1,25 @@ +// Package impl is the IMPLEMENTATION of the websocket agent: connect, send one +// message, read the echoed reply, and close — the whole client lifecycle of the +// SDK's websocket wrapper in one invocation. +package impl + +import ( + "agent-sdk-go/agents/wsecho" + + "github.com/golemcloud/golem/sdks/go/golem" + "github.com/golemcloud/golem/sdks/go/golem/websocket" +) + +type state struct{} + +var agent = golem.Implement(wsecho.Agent, func(wsecho.Id) *state { return &state{} }) + +func init() { + golem.Handle(agent, wsecho.Echo, func(_ *golem.Context[state], in wsecho.EchoIn) string { + conn := golem.Must(websocket.Connect(in.URL)) + golem.Must0(conn.SendText(in.Message)) + msg := golem.Must(conn.Receive()) + golem.Must0(conn.Close(1000, "done")) + return msg.Text() + }) +} diff --git a/test-components/agent-sdk-go/module/agents/wsecho/wsecho.go b/test-components/agent-sdk-go/module/agents/wsecho/wsecho.go new file mode 100644 index 0000000000..6b23d9c917 --- /dev/null +++ b/test-components/agent-sdk-go/module/agents/wsecho/wsecho.go @@ -0,0 +1,19 @@ +// Package wsecho is the DEFINITION of the agent exercising the SDK's websocket +// wrapper (golem/websocket). Behaviour lives in wsecho/impl. +package wsecho + +import "github.com/golemcloud/golem/sdks/go/golem" + +type Id struct{ Name string } + +type EchoIn struct { + URL string + Message string +} + +var Agent = golem.DefineAgent[Id](golem.Spec{ + Name: "WsAgent", Description: "Exercises the Go SDK websocket wrapper", Mode: golem.Durable, +}) + +var Echo = golem.DefineMethod[Id, EchoIn, string]("echo", + golem.Desc("Connect to the URL, send the message, and return the echoed reply")) diff --git a/test-components/agent-sdk-go/module/go.mod b/test-components/agent-sdk-go/module/go.mod new file mode 100644 index 0000000000..6323550d4c --- /dev/null +++ b/test-components/agent-sdk-go/module/go.mod @@ -0,0 +1,24 @@ +// Each Go component is its own module, with go.mod in the component directory: +// componentize-go discovers the SDK's WIT by scanning the module and its +// dependencies for componentize-go.toml, which only resolves from the module root. +module agent-sdk-go + +go 1.25.5 + +require github.com/golemcloud/golem/sdks/go/golem v0.0.0 + +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 +) + +// componentize-go is pinned per-app through this directive rather than installed +// globally, so `go tool componentize-go` always runs the pinned version. +tool github.com/bytecodealliance/componentize-go + +// Relative path to the in-repo SDK (like the Rust test components). The CLI's +// build-check may re-point this at GOLEM_GO_PATH when set. +replace github.com/golemcloud/golem/sdks/go/golem => ../../../sdks/go/golem diff --git a/test-components/agent-sdk-go/module/go.sum b/test-components/agent-sdk-go/module/go.sum new file mode 100644 index 0000000000..3a9de667b9 --- /dev/null +++ b/test-components/agent-sdk-go/module/go.sum @@ -0,0 +1,21 @@ +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/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/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 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +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= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/test-components/agent-sdk-go/module/main.go b/test-components/agent-sdk-go/module/main.go new file mode 100644 index 0000000000..fdf3672ab9 --- /dev/null +++ b/test-components/agent-sdk-go/module/main.go @@ -0,0 +1,27 @@ +// Package main is the barrel for the agent-sdk-go test component: it blank-imports +// each agent's IMPLEMENTATION package so their registration runs on import, and +// blank-imports the SDK so its runtime is linked. Agents live under agents// +// (definition = package , implementation = the impl subpackage). +package main + +import ( + _ "agent-sdk-go/agents/blobs/impl" + _ "agent-sdk-go/agents/clock/impl" + _ "agent-sdk-go/agents/configecho/impl" + _ "agent-sdk-go/agents/counter/impl" + _ "agent-sdk-go/agents/customdur/impl" + _ "agent-sdk-go/agents/httpcall/impl" + _ "agent-sdk-go/agents/kvstore/impl" + _ "agent-sdk-go/agents/ledger/impl" + _ "agent-sdk-go/agents/promises/impl" + _ "agent-sdk-go/agents/richtypes/impl" + _ "agent-sdk-go/agents/rpccaller/impl" + _ "agent-sdk-go/agents/saga/impl" + _ "agent-sdk-go/agents/scheduler/impl" + _ "agent-sdk-go/agents/snapstate/impl" + _ "agent-sdk-go/agents/wsecho/impl" + + _ "github.com/golemcloud/golem/sdks/go/golem" +) + +func main() {} diff --git a/test-components/build-components.sh b/test-components/build-components.sh index 6b4f6dc7d6..19fec7c0c3 100755 --- a/test-components/build-components.sh +++ b/test-components/build-components.sh @@ -4,10 +4,12 @@ IFS=$'\n\t' rust_test_apps=("oplog-processor" "host-api-tests" "http-tests" "initial-file-system" "agent-counters" "agent-updates-v1" "agent-updates-v2" "agent-updates-v3" "agent-updates-v4" "scalability" "agent-sdk-rust" "agent-invocation-context" "agent-mcp") ts_test_apps=("agent-constructor-parameter-echo" "agent-promise" "agent-sdk-ts" "agent-self-rpc" "agent-rpc") +go_test_apps=("agent-sdk-go") benchmark_apps=("benchmarks") RUST_CHUNKS=3 # Number of chunks to split rust apps into for parallel CI builds TS_CHUNKS=1 # Number of chunks to split ts apps into for parallel CI builds +GO_CHUNKS=1 # Number of chunks to split go apps into for parallel CI builds # Optional arguments: # - clean: clean all projects without building @@ -66,6 +68,10 @@ print_groups_json() { printf '%s{"name":"ts-%d","needs-node":true}' "$sep" "$i" sep="," done + for ((i=1; i<=GO_CHUNKS; i++)); do + printf '%s{"name":"go-%d","needs-node":false,"needs-go":true}' "$sep" "$i" + sep="," + done printf '%s{"name":"benchmarks","needs-node":true}]\n' "$sep" } @@ -85,12 +91,12 @@ for arg in "$@"; do check) check_only=true ;; - rust|ts|benchmarks) + rust|ts|go|benchmarks) single_group=true group="$arg" ;; - rust-*|ts-*) - if [[ "$arg" =~ ^(rust|ts)-([0-9]+)$ ]]; then + rust-*|ts-*|go-*) + if [[ "$arg" =~ ^(rust|ts|go)-([0-9]+)$ ]]; then single_group=true group="$arg" else @@ -173,6 +179,38 @@ build_rust_apps() { done } +build_go_apps() { + local apps=("$@") + if [ "$clean_only" = true ]; then + echo "Cleaning Go test apps" + elif [ "$check_only" = true ]; then + echo "Checking Go test apps" + else + echo "Building Go test apps" + fi + TEST_COMP_DIR="$(pwd)" + export GOLEM_GO_PATH="${TEST_COMP_DIR}/../sdks/go/golem" + for subdir in "${apps[@]}"; do + pushd "$subdir" || exit + + if should_clean; then + echo "Cleaning $subdir..." + "$GOLEM_CLI" clean + fi + + if [ "$check_only" = true ]; then + echo "Checking $subdir..." + "$GOLEM_CLI" build --step check --yes + elif [ "$clean_only" = false ]; then + echo "Building $subdir..." + "$GOLEM_CLI" --preset release build --yes --skip-check + "$GOLEM_CLI" --preset release exec copy + fi + + popd || exit + done +} + build_node_apps() { local apps=("$@") local label="${NODE_GROUP_LABEL:-Node}" @@ -235,6 +273,19 @@ elif [ "$single_group" = "false" ] || [ "$group" = "ts" ]; then NODE_GROUP_LABEL="TS" build_node_apps "${ts_test_apps[@]}" fi +if [[ "$group" =~ ^go-([0-9]+)$ ]]; then + chunk_idx="${BASH_REMATCH[1]}" + if [ "$chunk_idx" -lt 1 ] || [ "$chunk_idx" -gt "$GO_CHUNKS" ]; then + echo "Invalid go chunk: $chunk_idx (expected 1..$GO_CHUNKS)" >&2 + exit 1 + fi + get_chunk chunk_apps go_test_apps "$chunk_idx" "$GO_CHUNKS" + echo "Go chunk $chunk_idx/$GO_CHUNKS: ${chunk_apps[*]}" + build_go_apps "${chunk_apps[@]}" +elif [ "$single_group" = "false" ] || [ "$group" = "go" ]; then + build_go_apps "${go_test_apps[@]}" +fi + if [ "$single_group" = "false" ] || [ "$group" = "benchmarks" ]; then GOLEM_TS_PRESET=optimized NODE_GROUP_LABEL="benchmark" build_node_apps "${benchmark_apps[@]}" fi diff --git a/test-components/golem-test-components-common.yaml b/test-components/golem-test-components-common.yaml index 3a76a802d1..a77f1fb9e0 100644 --- a/test-components/golem-test-components-common.yaml +++ b/test-components/golem-test-components-common.yaml @@ -23,3 +23,7 @@ componentTemplates: customCommands: copy: - command: cp "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm" "{{ appRootDir }}/../{{ component_name | to_snake_case }}.wasm" + go-test-component: + customCommands: + copy: + - command: cp "{{ golemTempDir }}/agents/{{ component_name | to_snake_case }}.wasm" "{{ appRootDir }}/../{{ component_name | to_snake_case }}.wasm"