pumpkin-api-go/pkg/pumpkin_plugin_command/wit_bindings.go

// Generated by `wit-bindgen` 0.57.1. DO NOT EDIT!
//
// This code was generated from the following packages:
//     pumpkin:plugin@0.1.0

package pumpkin_plugin_command

import (
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_block_entity"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_common"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_player"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_server"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_text"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_world"
	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
	witTypes "go.bytecodealliance.org/pkg/wit/types"
	"math"
	"runtime"
	"unsafe"
)

type World = pumpkin_plugin_world.World
type Entity = pumpkin_plugin_world.Entity
type Player = pumpkin_plugin_player.Player
type CommandBlockEntity = pumpkin_plugin_block_entity.CommandBlockEntity
type Position = witTypes.Tuple3[float64, float64, float64]
type BlockPosition = witTypes.Tuple3[int32, int32, int32]
type Locale = pumpkin_plugin_common.Locale
type Server = pumpkin_plugin_server.Server
type Difficulty = pumpkin_plugin_server.Difficulty
type TextComponent = pumpkin_plugin_text.TextComponent

const (
	GamemodeSurvival  uint8 = 0
	GamemodeCreative  uint8 = 1
	GamemodeAdventure uint8 = 2
	GamemodeSpectator uint8 = 3
)

type Gamemode = uint8

const (
	BossbarColorPink   uint8 = 0
	BossbarColorBlue   uint8 = 1
	BossbarColorRed    uint8 = 2
	BossbarColorGreen  uint8 = 3
	BossbarColorYellow uint8 = 4
	BossbarColorPurple uint8 = 5
	BossbarColorWhite  uint8 = 6
)

type BossbarColor = uint8

const (
	BossbarStyleNoDivision uint8 = 0
	BossbarStyleNotches6   uint8 = 1
	BossbarStyleNotches10  uint8 = 2
	BossbarStyleNotches12  uint8 = 3
	BossbarStyleNotches20  uint8 = 4
)

type BossbarStyle = uint8

const (
	SoundCategoryMaster  uint8 = 0
	SoundCategoryMusic   uint8 = 1
	SoundCategoryRecords uint8 = 2
	SoundCategoryWeather uint8 = 3
	SoundCategoryBlocks  uint8 = 4
	SoundCategoryHostile uint8 = 5
	SoundCategoryNeutral uint8 = 6
	SoundCategoryPlayers uint8 = 7
	SoundCategoryAmbient uint8 = 8
	SoundCategoryVoice   uint8 = 9
	SoundCategoryUi      uint8 = 10
)

type SoundCategory = uint8

const (
	EntityAnchorFeet uint8 = 0
	EntityAnchorEyes uint8 = 1
)

type EntityAnchor = uint8

const (
	NumberFloat64 uint8 = 0
	NumberFloat32 uint8 = 1
	NumberInt32   uint8 = 2
	NumberInt64   uint8 = 3
)

type Number struct {
	tag   uint8
	value any
}

func (self Number) Tag() uint8 {
	return self.tag
}

func (self Number) Float64() float64 {
	if self.tag != NumberFloat64 {
		panic("tag mismatch")
	}
	return self.value.(float64)
}
func (self Number) Float32() float32 {
	if self.tag != NumberFloat32 {
		panic("tag mismatch")
	}
	return self.value.(float32)
}
func (self Number) Int32() int32 {
	if self.tag != NumberInt32 {
		panic("tag mismatch")
	}
	return self.value.(int32)
}
func (self Number) Int64() int64 {
	if self.tag != NumberInt64 {
		panic("tag mismatch")
	}
	return self.value.(int64)
}

func MakeNumberFloat64(value float64) Number {
	return Number{NumberFloat64, value}
}
func MakeNumberFloat32(value float32) Number {
	return Number{NumberFloat32, value}
}
func MakeNumberInt32(value int32) Number {
	return Number{NumberInt32, value}
}
func MakeNumberInt64(value int64) Number {
	return Number{NumberInt64, value}
}

const (
	NotInBoundsLowerBound uint8 = 0
	NotInBoundsUpperBound uint8 = 1
)

type NotInBounds struct {
	tag   uint8
	value any
}

func (self NotInBounds) Tag() uint8 {
	return self.tag
}

func (self NotInBounds) LowerBound() witTypes.Tuple2[Number, Number] {
	if self.tag != NotInBoundsLowerBound {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[Number, Number])
}
func (self NotInBounds) UpperBound() witTypes.Tuple2[Number, Number] {
	if self.tag != NotInBoundsUpperBound {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[Number, Number])
}

func MakeNotInBoundsLowerBound(value witTypes.Tuple2[Number, Number]) NotInBounds {
	return NotInBounds{NotInBoundsLowerBound, value}
}
func MakeNotInBoundsUpperBound(value witTypes.Tuple2[Number, Number]) NotInBounds {
	return NotInBounds{NotInBoundsUpperBound, value}
}

const (
	ArgEntities         uint8 = 0
	ArgEntity           uint8 = 1
	ArgPlayers          uint8 = 2
	ArgBlockPos         uint8 = 3
	ArgPos3d            uint8 = 4
	ArgPos2d            uint8 = 5
	ArgRotation         uint8 = 6
	ArgGameMode         uint8 = 7
	ArgDifficulty       uint8 = 8
	ArgItem             uint8 = 9
	ArgItemPredicate    uint8 = 10
	ArgResourceLocation uint8 = 11
	ArgBlock            uint8 = 12
	ArgBlockPredicate   uint8 = 13
	ArgBossbarColor     uint8 = 14
	ArgBossbarStyle     uint8 = 15
	ArgParticle         uint8 = 16
	ArgMsg              uint8 = 17
	ArgTextComponent    uint8 = 18
	ArgTime             uint8 = 19
	ArgNum              uint8 = 20
	ArgBool             uint8 = 21
	ArgSimple           uint8 = 22
	ArgSoundCategory    uint8 = 23
	ArgDamageType       uint8 = 24
	ArgEffect           uint8 = 25
	ArgEnchantment      uint8 = 26
	ArgEntityAnchor     uint8 = 27
)

type Arg struct {
	tag   uint8
	value any
}

func (self Arg) Tag() uint8 {
	return self.tag
}

func (self Arg) Entities() []*pumpkin_plugin_world.Entity {
	if self.tag != ArgEntities {
		panic("tag mismatch")
	}
	return self.value.([]*pumpkin_plugin_world.Entity)
}
func (self Arg) Entity() *pumpkin_plugin_world.Entity {
	if self.tag != ArgEntity {
		panic("tag mismatch")
	}
	return self.value.(*pumpkin_plugin_world.Entity)
}
func (self Arg) Players() []*pumpkin_plugin_player.Player {
	if self.tag != ArgPlayers {
		panic("tag mismatch")
	}
	return self.value.([]*pumpkin_plugin_player.Player)
}
func (self Arg) BlockPos() witTypes.Tuple3[int32, int32, int32] {
	if self.tag != ArgBlockPos {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple3[int32, int32, int32])
}
func (self Arg) Pos3d() witTypes.Tuple3[float64, float64, float64] {
	if self.tag != ArgPos3d {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple3[float64, float64, float64])
}
func (self Arg) Pos2d() witTypes.Tuple2[float64, float64] {
	if self.tag != ArgPos2d {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[float64, float64])
}
func (self Arg) Rotation() witTypes.Tuple4[float32, bool, float32, bool] {
	if self.tag != ArgRotation {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple4[float32, bool, float32, bool])
}
func (self Arg) GameMode() Gamemode {
	if self.tag != ArgGameMode {
		panic("tag mismatch")
	}
	return self.value.(Gamemode)
}
func (self Arg) Difficulty() pumpkin_plugin_server.Difficulty {
	if self.tag != ArgDifficulty {
		panic("tag mismatch")
	}
	return self.value.(pumpkin_plugin_server.Difficulty)
}
func (self Arg) Item() string {
	if self.tag != ArgItem {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) ItemPredicate() string {
	if self.tag != ArgItemPredicate {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) ResourceLocation() string {
	if self.tag != ArgResourceLocation {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) Block() string {
	if self.tag != ArgBlock {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) BlockPredicate() string {
	if self.tag != ArgBlockPredicate {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) BossbarColor() BossbarColor {
	if self.tag != ArgBossbarColor {
		panic("tag mismatch")
	}
	return self.value.(BossbarColor)
}
func (self Arg) BossbarStyle() BossbarStyle {
	if self.tag != ArgBossbarStyle {
		panic("tag mismatch")
	}
	return self.value.(BossbarStyle)
}
func (self Arg) Particle() string {
	if self.tag != ArgParticle {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) Msg() string {
	if self.tag != ArgMsg {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) TextComponent() *pumpkin_plugin_text.TextComponent {
	if self.tag != ArgTextComponent {
		panic("tag mismatch")
	}
	return self.value.(*pumpkin_plugin_text.TextComponent)
}
func (self Arg) Time() int32 {
	if self.tag != ArgTime {
		panic("tag mismatch")
	}
	return self.value.(int32)
}
func (self Arg) Num() witTypes.Result[Number, NotInBounds] {
	if self.tag != ArgNum {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Result[Number, NotInBounds])
}
func (self Arg) Bool() bool {
	if self.tag != ArgBool {
		panic("tag mismatch")
	}
	return self.value.(bool)
}
func (self Arg) Simple() string {
	if self.tag != ArgSimple {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) SoundCategory() SoundCategory {
	if self.tag != ArgSoundCategory {
		panic("tag mismatch")
	}
	return self.value.(SoundCategory)
}
func (self Arg) DamageType() string {
	if self.tag != ArgDamageType {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) Effect() string {
	if self.tag != ArgEffect {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) Enchantment() string {
	if self.tag != ArgEnchantment {
		panic("tag mismatch")
	}
	return self.value.(string)
}
func (self Arg) EntityAnchor() EntityAnchor {
	if self.tag != ArgEntityAnchor {
		panic("tag mismatch")
	}
	return self.value.(EntityAnchor)
}

func MakeArgEntities(value []*pumpkin_plugin_world.Entity) Arg {
	return Arg{ArgEntities, value}
}
func MakeArgEntity(value *pumpkin_plugin_world.Entity) Arg {
	return Arg{ArgEntity, value}
}
func MakeArgPlayers(value []*pumpkin_plugin_player.Player) Arg {
	return Arg{ArgPlayers, value}
}
func MakeArgBlockPos(value witTypes.Tuple3[int32, int32, int32]) Arg {
	return Arg{ArgBlockPos, value}
}
func MakeArgPos3d(value witTypes.Tuple3[float64, float64, float64]) Arg {
	return Arg{ArgPos3d, value}
}
func MakeArgPos2d(value witTypes.Tuple2[float64, float64]) Arg {
	return Arg{ArgPos2d, value}
}
func MakeArgRotation(value witTypes.Tuple4[float32, bool, float32, bool]) Arg {
	return Arg{ArgRotation, value}
}
func MakeArgGameMode(value Gamemode) Arg {
	return Arg{ArgGameMode, value}
}
func MakeArgDifficulty(value pumpkin_plugin_server.Difficulty) Arg {
	return Arg{ArgDifficulty, value}
}
func MakeArgItem(value string) Arg {
	return Arg{ArgItem, value}
}
func MakeArgItemPredicate(value string) Arg {
	return Arg{ArgItemPredicate, value}
}
func MakeArgResourceLocation(value string) Arg {
	return Arg{ArgResourceLocation, value}
}
func MakeArgBlock(value string) Arg {
	return Arg{ArgBlock, value}
}
func MakeArgBlockPredicate(value string) Arg {
	return Arg{ArgBlockPredicate, value}
}
func MakeArgBossbarColor(value BossbarColor) Arg {
	return Arg{ArgBossbarColor, value}
}
func MakeArgBossbarStyle(value BossbarStyle) Arg {
	return Arg{ArgBossbarStyle, value}
}
func MakeArgParticle(value string) Arg {
	return Arg{ArgParticle, value}
}
func MakeArgMsg(value string) Arg {
	return Arg{ArgMsg, value}
}
func MakeArgTextComponent(value *pumpkin_plugin_text.TextComponent) Arg {
	return Arg{ArgTextComponent, value}
}
func MakeArgTime(value int32) Arg {
	return Arg{ArgTime, value}
}
func MakeArgNum(value witTypes.Result[Number, NotInBounds]) Arg {
	return Arg{ArgNum, value}
}
func MakeArgBool(value bool) Arg {
	return Arg{ArgBool, value}
}
func MakeArgSimple(value string) Arg {
	return Arg{ArgSimple, value}
}
func MakeArgSoundCategory(value SoundCategory) Arg {
	return Arg{ArgSoundCategory, value}
}
func MakeArgDamageType(value string) Arg {
	return Arg{ArgDamageType, value}
}
func MakeArgEffect(value string) Arg {
	return Arg{ArgEffect, value}
}
func MakeArgEnchantment(value string) Arg {
	return Arg{ArgEnchantment, value}
}
func MakeArgEntityAnchor(value EntityAnchor) Arg {
	return Arg{ArgEntityAnchor, value}
}

//go:wasmimport pumpkin:plugin/command@0.1.0 [resource-drop]consumed-args
func resourceDropConsumedArgs(handle int32)

type ConsumedArgs struct {
	handle *witRuntime.Handle
}

func (self *ConsumedArgs) TakeHandle() int32 {
	return self.handle.Take()
}

func (self *ConsumedArgs) SetHandle(handle int32) {
	self.handle.Set(handle)
}

func (self *ConsumedArgs) Handle() int32 {
	return self.handle.Use()
}

func (self *ConsumedArgs) Drop() {
	handle := self.handle.TakeOrNil()
	if handle != 0 {
		resourceDropConsumedArgs(handle)
	}
}

func ConsumedArgsFromOwnHandle(handleValue int32) *ConsumedArgs {
	handle := witRuntime.MakeHandle(handleValue)
	value := &ConsumedArgs{handle}
	runtime.AddCleanup(value, func(_ int) {
		handleValue := handle.TakeOrNil()
		if handleValue != 0 {
			resourceDropConsumedArgs(handleValue)
		}
	}, 0)
	return value
}

func ConsumedArgsFromBorrowHandle(handleValue int32) *ConsumedArgs {
	handle := witRuntime.MakeHandle(handleValue)
	return &ConsumedArgs{handle}
}

const (
	CommandSenderTypeRcon         uint8 = 0
	CommandSenderTypeConsole      uint8 = 1
	CommandSenderTypePlayer       uint8 = 2
	CommandSenderTypeCommandBlock uint8 = 3
	CommandSenderTypeDummy        uint8 = 4
)

type CommandSenderType struct {
	tag   uint8
	value any
}

func (self CommandSenderType) Tag() uint8 {
	return self.tag
}

func (self CommandSenderType) Player() *pumpkin_plugin_player.Player {
	if self.tag != CommandSenderTypePlayer {
		panic("tag mismatch")
	}
	return self.value.(*pumpkin_plugin_player.Player)
}
func (self CommandSenderType) CommandBlock() witTypes.Tuple2[*pumpkin_plugin_block_entity.CommandBlockEntity, *pumpkin_plugin_world.World] {
	if self.tag != CommandSenderTypeCommandBlock {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[*pumpkin_plugin_block_entity.CommandBlockEntity, *pumpkin_plugin_world.World])
}

func MakeCommandSenderTypeRcon() CommandSenderType {
	return CommandSenderType{CommandSenderTypeRcon, nil}
}
func MakeCommandSenderTypeConsole() CommandSenderType {
	return CommandSenderType{CommandSenderTypeConsole, nil}
}
func MakeCommandSenderTypePlayer(value *pumpkin_plugin_player.Player) CommandSenderType {
	return CommandSenderType{CommandSenderTypePlayer, value}
}
func MakeCommandSenderTypeCommandBlock(value witTypes.Tuple2[*pumpkin_plugin_block_entity.CommandBlockEntity, *pumpkin_plugin_world.World]) CommandSenderType {
	return CommandSenderType{CommandSenderTypeCommandBlock, value}
}
func MakeCommandSenderTypeDummy() CommandSenderType {
	return CommandSenderType{CommandSenderTypeDummy, nil}
}

const (
	PermissionLevelZero  uint8 = 0
	PermissionLevelOne   uint8 = 1
	PermissionLevelTwo   uint8 = 2
	PermissionLevelThree uint8 = 3
	PermissionLevelFour  uint8 = 4
)

type PermissionLevel = uint8

//go:wasmimport pumpkin:plugin/command@0.1.0 [resource-drop]command-sender
func resourceDropCommandSender(handle int32)

type CommandSender struct {
	handle *witRuntime.Handle
}

func (self *CommandSender) TakeHandle() int32 {
	return self.handle.Take()
}

func (self *CommandSender) SetHandle(handle int32) {
	self.handle.Set(handle)
}

func (self *CommandSender) Handle() int32 {
	return self.handle.Use()
}

func (self *CommandSender) Drop() {
	handle := self.handle.TakeOrNil()
	if handle != 0 {
		resourceDropCommandSender(handle)
	}
}

func CommandSenderFromOwnHandle(handleValue int32) *CommandSender {
	handle := witRuntime.MakeHandle(handleValue)
	value := &CommandSender{handle}
	runtime.AddCleanup(value, func(_ int) {
		handleValue := handle.TakeOrNil()
		if handleValue != 0 {
			resourceDropCommandSender(handleValue)
		}
	}, 0)
	return value
}

func CommandSenderFromBorrowHandle(handleValue int32) *CommandSender {
	handle := witRuntime.MakeHandle(handleValue)
	return &CommandSender{handle}
}

const (
	StringTypeSingleWord uint8 = 0
	StringTypeQuotable   uint8 = 1
	StringTypeGreedy     uint8 = 2
)

type StringType = uint8

const (
	ArgumentTypeBool             uint8 = 0
	ArgumentTypeFloat            uint8 = 1
	ArgumentTypeDouble           uint8 = 2
	ArgumentTypeInteger          uint8 = 3
	ArgumentTypeLong             uint8 = 4
	ArgumentTypeString           uint8 = 5
	ArgumentTypeEntities         uint8 = 6
	ArgumentTypeEntity           uint8 = 7
	ArgumentTypePlayers          uint8 = 8
	ArgumentTypeGameProfile      uint8 = 9
	ArgumentTypeBlockPos         uint8 = 10
	ArgumentTypePosition3d       uint8 = 11
	ArgumentTypePosition2d       uint8 = 12
	ArgumentTypeBlockState       uint8 = 13
	ArgumentTypeBlockPredicate   uint8 = 14
	ArgumentTypeItem             uint8 = 15
	ArgumentTypeItemPredicate    uint8 = 16
	ArgumentTypeComponent        uint8 = 17
	ArgumentTypeRotation         uint8 = 18
	ArgumentTypeResourceLocation uint8 = 19
	ArgumentTypeEntityAnchor     uint8 = 20
	ArgumentTypeGamemode         uint8 = 21
	ArgumentTypeDifficulty       uint8 = 22
	ArgumentTypeTime             uint8 = 23
	ArgumentTypeResource         uint8 = 24
)

type ArgumentType struct {
	tag   uint8
	value any
}

func (self ArgumentType) Tag() uint8 {
	return self.tag
}

func (self ArgumentType) Float() witTypes.Tuple2[witTypes.Option[float32], witTypes.Option[float32]] {
	if self.tag != ArgumentTypeFloat {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[witTypes.Option[float32], witTypes.Option[float32]])
}
func (self ArgumentType) Double() witTypes.Tuple2[witTypes.Option[float64], witTypes.Option[float64]] {
	if self.tag != ArgumentTypeDouble {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[witTypes.Option[float64], witTypes.Option[float64]])
}
func (self ArgumentType) Integer() witTypes.Tuple2[witTypes.Option[int32], witTypes.Option[int32]] {
	if self.tag != ArgumentTypeInteger {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[witTypes.Option[int32], witTypes.Option[int32]])
}
func (self ArgumentType) Long() witTypes.Tuple2[witTypes.Option[int64], witTypes.Option[int64]] {
	if self.tag != ArgumentTypeLong {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Tuple2[witTypes.Option[int64], witTypes.Option[int64]])
}
func (self ArgumentType) String() StringType {
	if self.tag != ArgumentTypeString {
		panic("tag mismatch")
	}
	return self.value.(StringType)
}
func (self ArgumentType) Time() int32 {
	if self.tag != ArgumentTypeTime {
		panic("tag mismatch")
	}
	return self.value.(int32)
}
func (self ArgumentType) Resource() string {
	if self.tag != ArgumentTypeResource {
		panic("tag mismatch")
	}
	return self.value.(string)
}

func MakeArgumentTypeBool() ArgumentType {
	return ArgumentType{ArgumentTypeBool, nil}
}
func MakeArgumentTypeFloat(value witTypes.Tuple2[witTypes.Option[float32], witTypes.Option[float32]]) ArgumentType {
	return ArgumentType{ArgumentTypeFloat, value}
}
func MakeArgumentTypeDouble(value witTypes.Tuple2[witTypes.Option[float64], witTypes.Option[float64]]) ArgumentType {
	return ArgumentType{ArgumentTypeDouble, value}
}
func MakeArgumentTypeInteger(value witTypes.Tuple2[witTypes.Option[int32], witTypes.Option[int32]]) ArgumentType {
	return ArgumentType{ArgumentTypeInteger, value}
}
func MakeArgumentTypeLong(value witTypes.Tuple2[witTypes.Option[int64], witTypes.Option[int64]]) ArgumentType {
	return ArgumentType{ArgumentTypeLong, value}
}
func MakeArgumentTypeString(value StringType) ArgumentType {
	return ArgumentType{ArgumentTypeString, value}
}
func MakeArgumentTypeEntities() ArgumentType {
	return ArgumentType{ArgumentTypeEntities, nil}
}
func MakeArgumentTypeEntity() ArgumentType {
	return ArgumentType{ArgumentTypeEntity, nil}
}
func MakeArgumentTypePlayers() ArgumentType {
	return ArgumentType{ArgumentTypePlayers, nil}
}
func MakeArgumentTypeGameProfile() ArgumentType {
	return ArgumentType{ArgumentTypeGameProfile, nil}
}
func MakeArgumentTypeBlockPos() ArgumentType {
	return ArgumentType{ArgumentTypeBlockPos, nil}
}
func MakeArgumentTypePosition3d() ArgumentType {
	return ArgumentType{ArgumentTypePosition3d, nil}
}
func MakeArgumentTypePosition2d() ArgumentType {
	return ArgumentType{ArgumentTypePosition2d, nil}
}
func MakeArgumentTypeBlockState() ArgumentType {
	return ArgumentType{ArgumentTypeBlockState, nil}
}
func MakeArgumentTypeBlockPredicate() ArgumentType {
	return ArgumentType{ArgumentTypeBlockPredicate, nil}
}
func MakeArgumentTypeItem() ArgumentType {
	return ArgumentType{ArgumentTypeItem, nil}
}
func MakeArgumentTypeItemPredicate() ArgumentType {
	return ArgumentType{ArgumentTypeItemPredicate, nil}
}
func MakeArgumentTypeComponent() ArgumentType {
	return ArgumentType{ArgumentTypeComponent, nil}
}
func MakeArgumentTypeRotation() ArgumentType {
	return ArgumentType{ArgumentTypeRotation, nil}
}
func MakeArgumentTypeResourceLocation() ArgumentType {
	return ArgumentType{ArgumentTypeResourceLocation, nil}
}
func MakeArgumentTypeEntityAnchor() ArgumentType {
	return ArgumentType{ArgumentTypeEntityAnchor, nil}
}
func MakeArgumentTypeGamemode() ArgumentType {
	return ArgumentType{ArgumentTypeGamemode, nil}
}
func MakeArgumentTypeDifficulty() ArgumentType {
	return ArgumentType{ArgumentTypeDifficulty, nil}
}
func MakeArgumentTypeTime(value int32) ArgumentType {
	return ArgumentType{ArgumentTypeTime, value}
}
func MakeArgumentTypeResource(value string) ArgumentType {
	return ArgumentType{ArgumentTypeResource, value}
}

const (
	CommandErrorInvalidConsumption uint8 = 0
	CommandErrorInvalidRequirement uint8 = 1
	CommandErrorPermissionDenied   uint8 = 2
	CommandErrorCommandFailed      uint8 = 3
)

type CommandError struct {
	tag   uint8
	value any
}

func (self CommandError) Tag() uint8 {
	return self.tag
}

func (self CommandError) InvalidConsumption() witTypes.Option[string] {
	if self.tag != CommandErrorInvalidConsumption {
		panic("tag mismatch")
	}
	return self.value.(witTypes.Option[string])
}
func (self CommandError) CommandFailed() *pumpkin_plugin_text.TextComponent {
	if self.tag != CommandErrorCommandFailed {
		panic("tag mismatch")
	}
	return self.value.(*pumpkin_plugin_text.TextComponent)
}

func MakeCommandErrorInvalidConsumption(value witTypes.Option[string]) CommandError {
	return CommandError{CommandErrorInvalidConsumption, value}
}
func MakeCommandErrorInvalidRequirement() CommandError {
	return CommandError{CommandErrorInvalidRequirement, nil}
}
func MakeCommandErrorPermissionDenied() CommandError {
	return CommandError{CommandErrorPermissionDenied, nil}
}
func MakeCommandErrorCommandFailed(value *pumpkin_plugin_text.TextComponent) CommandError {
	return CommandError{CommandErrorCommandFailed, value}
}

//go:wasmimport pumpkin:plugin/command@0.1.0 [resource-drop]command-node
func resourceDropCommandNode(handle int32)

type CommandNode struct {
	handle *witRuntime.Handle
}

func (self *CommandNode) TakeHandle() int32 {
	return self.handle.Take()
}

func (self *CommandNode) SetHandle(handle int32) {
	self.handle.Set(handle)
}

func (self *CommandNode) Handle() int32 {
	return self.handle.Use()
}

func (self *CommandNode) Drop() {
	handle := self.handle.TakeOrNil()
	if handle != 0 {
		resourceDropCommandNode(handle)
	}
}

func CommandNodeFromOwnHandle(handleValue int32) *CommandNode {
	handle := witRuntime.MakeHandle(handleValue)
	value := &CommandNode{handle}
	runtime.AddCleanup(value, func(_ int) {
		handleValue := handle.TakeOrNil()
		if handleValue != 0 {
			resourceDropCommandNode(handleValue)
		}
	}, 0)
	return value
}

func CommandNodeFromBorrowHandle(handleValue int32) *CommandNode {
	handle := witRuntime.MakeHandle(handleValue)
	return &CommandNode{handle}
}

//go:wasmimport pumpkin:plugin/command@0.1.0 [resource-drop]command
func resourceDropCommand(handle int32)

type Command struct {
	handle *witRuntime.Handle
}

func (self *Command) TakeHandle() int32 {
	return self.handle.Take()
}

func (self *Command) SetHandle(handle int32) {
	self.handle.Set(handle)
}

func (self *Command) Handle() int32 {
	return self.handle.Use()
}

func (self *Command) Drop() {
	handle := self.handle.TakeOrNil()
	if handle != 0 {
		resourceDropCommand(handle)
	}
}

func CommandFromOwnHandle(handleValue int32) *Command {
	handle := witRuntime.MakeHandle(handleValue)
	value := &Command{handle}
	runtime.AddCleanup(value, func(_ int) {
		handleValue := handle.TakeOrNil()
		if handleValue != 0 {
			resourceDropCommand(handleValue)
		}
	}, 0)
	return value
}

func CommandFromBorrowHandle(handleValue int32) *Command {
	handle := witRuntime.MakeHandle(handleValue)
	return &Command{handle}
}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]consumed-args.get-value
func wasm_import_method_consumed_args_get_value(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)

func (self *ConsumedArgs) GetValue(key string) Arg {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 56, 8))
	utf8 := unsafe.Pointer(unsafe.StringData(key))
	pinner.Pin(utf8)
	wasm_import_method_consumed_args_get_value((self).Handle(), uintptr(utf8), uint32(len(key)), returnArea)
	var variant17 Arg
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:
		result := make([]*pumpkin_plugin_world.Entity, 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)

			result = append(result, pumpkin_plugin_world.EntityFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
		}

		variant17 = MakeArgEntities(result)

	case 1:

		variant17 = MakeArgEntity(pumpkin_plugin_world.EntityFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))))

	case 2:
		result0 := make([]*pumpkin_plugin_player.Player, 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)

			result0 = append(result0, pumpkin_plugin_player.PlayerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
		}

		variant17 = MakeArgPlayers(result0)

	case 3:

		variant17 = MakeArgBlockPos(witTypes.Tuple3[int32, int32, int32]{*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 12)), *(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 16))})

	case 4:

		variant17 = MakeArgPos3d(witTypes.Tuple3[float64, float64, float64]{*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 16)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 24))})

	case 5:

		variant17 = MakeArgPos2d(witTypes.Tuple2[float64, float64]{*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 16))})

	case 6:

		variant17 = MakeArgRotation(witTypes.Tuple4[float32, bool, float32, bool]{*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 12))) != 0), *(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 16)), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 20))) != 0)})

	case 7:

		variant17 = MakeArgGameMode(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))

	case 8:

		variant17 = MakeArgDifficulty(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))

	case 9:
		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgItem(value)

	case 10:
		value1 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgItemPredicate(value1)

	case 11:
		value2 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgResourceLocation(value2)

	case 12:
		value3 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgBlock(value3)

	case 13:
		value4 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgBlockPredicate(value4)

	case 14:

		variant17 = MakeArgBossbarColor(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))

	case 15:

		variant17 = MakeArgBossbarStyle(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))

	case 16:
		value5 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgParticle(value5)

	case 17:
		value6 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgMsg(value6)

	case 18:

		variant17 = MakeArgTextComponent(pumpkin_plugin_text.TextComponentFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))))

	case 19:

		variant17 = MakeArgTime(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))

	case 20:
		var result12 witTypes.Result[Number, NotInBounds]
		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) {
		case 0:
			var variant Number
			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
			case 0:

				variant = MakeNumberFloat64(*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 24)))

			case 1:

				variant = MakeNumberFloat32(*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 24)))

			case 2:

				variant = MakeNumberInt32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 24)))

			case 3:

				variant = MakeNumberInt64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 24)))

			default:
				panic("unreachable")
			}

			result12 = witTypes.Ok[Number, NotInBounds](variant)
		case 1:
			var variant11 NotInBounds
			switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 16))) {
			case 0:
				var variant7 Number
				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))) {
				case 0:

					variant7 = MakeNumberFloat64(*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				case 1:

					variant7 = MakeNumberFloat32(*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				case 2:

					variant7 = MakeNumberInt32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				case 3:

					variant7 = MakeNumberInt64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				default:
					panic("unreachable")
				}
				var variant8 Number
				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 40))) {
				case 0:

					variant8 = MakeNumberFloat64(*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				case 1:

					variant8 = MakeNumberFloat32(*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				case 2:

					variant8 = MakeNumberInt32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				case 3:

					variant8 = MakeNumberInt64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				default:
					panic("unreachable")
				}

				variant11 = MakeNotInBoundsLowerBound(witTypes.Tuple2[Number, Number]{variant7, variant8})

			case 1:
				var variant9 Number
				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 24))) {
				case 0:

					variant9 = MakeNumberFloat64(*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				case 1:

					variant9 = MakeNumberFloat32(*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				case 2:

					variant9 = MakeNumberInt32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				case 3:

					variant9 = MakeNumberInt64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 32)))

				default:
					panic("unreachable")
				}
				var variant10 Number
				switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 40))) {
				case 0:

					variant10 = MakeNumberFloat64(*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				case 1:

					variant10 = MakeNumberFloat32(*(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				case 2:

					variant10 = MakeNumberInt32(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				case 3:

					variant10 = MakeNumberInt64(*(*int64)(unsafe.Add(unsafe.Pointer(returnArea), 48)))

				default:
					panic("unreachable")
				}

				variant11 = MakeNotInBoundsUpperBound(witTypes.Tuple2[Number, Number]{variant9, variant10})

			default:
				panic("unreachable")
			}

			result12 = witTypes.Err[Number, NotInBounds](variant11)
		default:
			panic("unreachable")
		}

		variant17 = MakeArgNum(result12)

	case 21:

		variant17 = MakeArgBool((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))) != 0))

	case 22:
		value13 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgSimple(value13)

	case 23:

		variant17 = MakeArgSoundCategory(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))

	case 24:
		value14 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgDamageType(value14)

	case 25:
		value15 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgEffect(value15)

	case 26:
		value16 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (8 + 1*4))))

		variant17 = MakeArgEnchantment(value16)

	case 27:

		variant17 = MakeArgEntityAnchor(uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))

	default:
		panic("unreachable")
	}
	result18 := variant17
	return result18

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.get-command-sender-type
func wasm_import_method_command_sender_get_command_sender_type(arg0 int32, arg1 uintptr)

func (self *CommandSender) GetCommandSenderType() CommandSenderType {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 12, 4))
	wasm_import_method_command_sender_get_command_sender_type((self).Handle(), returnArea)
	var variant CommandSenderType
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		variant = MakeCommandSenderTypeRcon()

	case 1:

		variant = MakeCommandSenderTypeConsole()

	case 2:

		variant = MakeCommandSenderTypePlayer(pumpkin_plugin_player.PlayerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))

	case 3:

		variant = MakeCommandSenderTypeCommandBlock(witTypes.Tuple2[*pumpkin_plugin_block_entity.CommandBlockEntity, *pumpkin_plugin_world.World]{pumpkin_plugin_block_entity.CommandBlockEntityFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), pumpkin_plugin_world.WorldFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 8)))))})

	case 4:

		variant = MakeCommandSenderTypeDummy()

	default:
		panic("unreachable")
	}
	result := variant
	return result

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.send-message
func wasm_import_method_command_sender_send_message(arg0 int32, arg1 int32)

func (self *CommandSender) SendMessage(text *pumpkin_plugin_text.TextComponent) {

	wasm_import_method_command_sender_send_message((self).Handle(), (text).TakeHandle())

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.set-success-count
func wasm_import_method_command_sender_set_success_count(arg0 int32, arg1 int32)

func (self *CommandSender) SetSuccessCount(count int32) {

	wasm_import_method_command_sender_set_success_count((self).Handle(), count)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.is-player
func wasm_import_method_command_sender_is_player(arg0 int32) int32

func (self *CommandSender) IsPlayer() bool {

	result := wasm_import_method_command_sender_is_player((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.is-console
func wasm_import_method_command_sender_is_console(arg0 int32) int32

func (self *CommandSender) IsConsole() bool {

	result := wasm_import_method_command_sender_is_console((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.as-player
func wasm_import_method_command_sender_as_player(arg0 int32, arg1 uintptr)

func (self *CommandSender) AsPlayer() witTypes.Option[*pumpkin_plugin_player.Player] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
	wasm_import_method_command_sender_as_player((self).Handle(), returnArea)
	var option witTypes.Option[*pumpkin_plugin_player.Player]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[*pumpkin_plugin_player.Player]()
	case 1:

		option = witTypes.Some[*pumpkin_plugin_player.Player](pumpkin_plugin_player.PlayerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.permission-level
func wasm_import_method_command_sender_permission_level(arg0 int32) int32

func (self *CommandSender) PermissionLevel() PermissionLevel {

	result := wasm_import_method_command_sender_permission_level((self).Handle())
	return uint8(result)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.has-permission-level
func wasm_import_method_command_sender_has_permission_level(arg0 int32, arg1 int32) int32

func (self *CommandSender) HasPermissionLevel(level PermissionLevel) bool {

	result := wasm_import_method_command_sender_has_permission_level((self).Handle(), int32(level))
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.has-permission
func wasm_import_method_command_sender_has_permission(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32) int32

func (self *CommandSender) HasPermission(server *pumpkin_plugin_server.Server, node string) bool {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(node))
	pinner.Pin(utf8)
	result := wasm_import_method_command_sender_has_permission((self).Handle(), (server).Handle(), uintptr(utf8), uint32(len(node)))
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.position
func wasm_import_method_command_sender_position(arg0 int32, arg1 uintptr)

func (self *CommandSender) Position() witTypes.Option[witTypes.Tuple3[float64, float64, float64]] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 32, 8))
	wasm_import_method_command_sender_position((self).Handle(), returnArea)
	var option witTypes.Option[witTypes.Tuple3[float64, float64, float64]]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[witTypes.Tuple3[float64, float64, float64]]()
	case 1:

		option = witTypes.Some[witTypes.Tuple3[float64, float64, float64]](witTypes.Tuple3[float64, float64, float64]{*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 16)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 24))})
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.world
func wasm_import_method_command_sender_world(arg0 int32, arg1 uintptr)

func (self *CommandSender) World() witTypes.Option[*pumpkin_plugin_world.World] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
	wasm_import_method_command_sender_world((self).Handle(), returnArea)
	var option witTypes.Option[*pumpkin_plugin_world.World]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[*pumpkin_plugin_world.World]()
	case 1:

		option = witTypes.Some[*pumpkin_plugin_world.World](pumpkin_plugin_world.WorldFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.get-locale
func wasm_import_method_command_sender_get_locale(arg0 int32) int32

func (self *CommandSender) GetLocale() pumpkin_plugin_common.Locale {

	result := wasm_import_method_command_sender_get_locale((self).Handle())
	return uint8(result)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.should-receive-feedback
func wasm_import_method_command_sender_should_receive_feedback(arg0 int32) int32

func (self *CommandSender) ShouldReceiveFeedback() bool {

	result := wasm_import_method_command_sender_should_receive_feedback((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.should-broadcast-console-to-ops
func wasm_import_method_command_sender_should_broadcast_console_to_ops(arg0 int32) int32

func (self *CommandSender) ShouldBroadcastConsoleToOps() bool {

	result := wasm_import_method_command_sender_should_broadcast_console_to_ops((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-sender.should-track-output
func wasm_import_method_command_sender_should_track_output(arg0 int32) int32

func (self *CommandSender) ShouldTrackOutput() bool {

	result := wasm_import_method_command_sender_should_track_output((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [static]command-node.literal
func wasm_import_static_command_node_literal(arg0 uintptr, arg1 uint32) int32

func CommandNodeLiteral(name string) *CommandNode {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(name))
	pinner.Pin(utf8)
	result := wasm_import_static_command_node_literal(uintptr(utf8), uint32(len(name)))
	return CommandNodeFromOwnHandle(int32(uintptr(result)))

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [static]command-node.argument
func wasm_import_static_command_node_argument(arg0 uintptr, arg1 uint32, arg2 int32, arg3 uintptr, arg4 int64, arg5 int32, arg6 int64) int32

func CommandNodeArgument(name string, argType ArgumentType) *CommandNode {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(name))
	pinner.Pin(utf8)
	var variant int32
	var variant16 uintptr
	var variant17 int64
	var variant18 int32
	var variant19 int64
	switch argType.Tag() {
	case ArgumentTypeBool:

		variant = int32(0)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeFloat:
		payload := argType.Float()
		var option int32
		var option0 float32
		switch (payload).F0.Tag() {
		case witTypes.OptionNone:

			option = int32(0)
			option0 = 0
		case witTypes.OptionSome:
			payload := (payload).F0.Some()

			option = int32(1)
			option0 = payload
		default:
			panic("unreachable")
		}
		var option1 int32
		var option2 float32
		switch (payload).F1.Tag() {
		case witTypes.OptionNone:

			option1 = int32(0)
			option2 = 0
		case witTypes.OptionSome:
			payload := (payload).F1.Some()

			option1 = int32(1)
			option2 = payload
		default:
			panic("unreachable")
		}

		variant = int32(1)
		variant16 = uintptr(option)
		variant17 = int64(math.Float32bits(option0))
		variant18 = option1
		variant19 = int64(math.Float32bits(option2))

	case ArgumentTypeDouble:
		payload := argType.Double()
		var option3 int32
		var option4 float64
		switch (payload).F0.Tag() {
		case witTypes.OptionNone:

			option3 = int32(0)
			option4 = 0
		case witTypes.OptionSome:
			payload := (payload).F0.Some()

			option3 = int32(1)
			option4 = payload
		default:
			panic("unreachable")
		}
		var option5 int32
		var option6 float64
		switch (payload).F1.Tag() {
		case witTypes.OptionNone:

			option5 = int32(0)
			option6 = 0
		case witTypes.OptionSome:
			payload := (payload).F1.Some()

			option5 = int32(1)
			option6 = payload
		default:
			panic("unreachable")
		}

		variant = int32(2)
		variant16 = uintptr(option3)
		variant17 = int64(math.Float64bits(option4))
		variant18 = option5
		variant19 = int64(math.Float64bits(option6))

	case ArgumentTypeInteger:
		payload := argType.Integer()
		var option7 int32
		var option8 int32
		switch (payload).F0.Tag() {
		case witTypes.OptionNone:

			option7 = int32(0)
			option8 = 0
		case witTypes.OptionSome:
			payload := (payload).F0.Some()

			option7 = int32(1)
			option8 = payload
		default:
			panic("unreachable")
		}
		var option9 int32
		var option10 int32
		switch (payload).F1.Tag() {
		case witTypes.OptionNone:

			option9 = int32(0)
			option10 = 0
		case witTypes.OptionSome:
			payload := (payload).F1.Some()

			option9 = int32(1)
			option10 = payload
		default:
			panic("unreachable")
		}

		variant = int32(3)
		variant16 = uintptr(option7)
		variant17 = int64(option8)
		variant18 = option9
		variant19 = int64(option10)

	case ArgumentTypeLong:
		payload := argType.Long()
		var option11 int32
		var option12 int64
		switch (payload).F0.Tag() {
		case witTypes.OptionNone:

			option11 = int32(0)
			option12 = 0
		case witTypes.OptionSome:
			payload := (payload).F0.Some()

			option11 = int32(1)
			option12 = payload
		default:
			panic("unreachable")
		}
		var option13 int32
		var option14 int64
		switch (payload).F1.Tag() {
		case witTypes.OptionNone:

			option13 = int32(0)
			option14 = 0
		case witTypes.OptionSome:
			payload := (payload).F1.Some()

			option13 = int32(1)
			option14 = payload
		default:
			panic("unreachable")
		}

		variant = int32(4)
		variant16 = uintptr(option11)
		variant17 = option12
		variant18 = option13
		variant19 = option14

	case ArgumentTypeString:
		payload := argType.String()

		variant = int32(5)
		variant16 = uintptr(int32(payload))
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeEntities:

		variant = int32(6)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeEntity:

		variant = int32(7)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypePlayers:

		variant = int32(8)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeGameProfile:

		variant = int32(9)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeBlockPos:

		variant = int32(10)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypePosition3d:

		variant = int32(11)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypePosition2d:

		variant = int32(12)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeBlockState:

		variant = int32(13)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeBlockPredicate:

		variant = int32(14)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeItem:

		variant = int32(15)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeItemPredicate:

		variant = int32(16)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeComponent:

		variant = int32(17)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeRotation:

		variant = int32(18)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeResourceLocation:

		variant = int32(19)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeEntityAnchor:

		variant = int32(20)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeGamemode:

		variant = int32(21)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeDifficulty:

		variant = int32(22)
		variant16 = 0
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeTime:
		payload := argType.Time()

		variant = int32(23)
		variant16 = uintptr(payload)
		variant17 = 0
		variant18 = 0
		variant19 = 0

	case ArgumentTypeResource:
		payload := argType.Resource()
		utf815 := unsafe.Pointer(unsafe.StringData(payload))
		pinner.Pin(utf815)

		variant = int32(24)
		variant16 = uintptr(utf815)
		variant17 = int64(uint32(len(payload)))
		variant18 = 0
		variant19 = 0

	default:
		panic("unreachable")
	}
	result := wasm_import_static_command_node_argument(uintptr(utf8), uint32(len(name)), variant, variant16, variant17, variant18, variant19)
	return CommandNodeFromOwnHandle(int32(uintptr(result)))

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-node.then
func wasm_import_method_command_node_then(arg0 int32, arg1 int32)

func (self *CommandNode) Then(node *CommandNode) {

	wasm_import_method_command_node_then((self).Handle(), (node).TakeHandle())

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-node.execute-with-handler-id
func wasm_import_method_command_node_execute_with_handler_id(arg0 int32, arg1 int32)

func (self *CommandNode) ExecuteWithHandlerId(handlerId uint32) {

	wasm_import_method_command_node_execute_with_handler_id((self).Handle(), int32(handlerId))

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command-node.require-with-handler-id
func wasm_import_method_command_node_require_with_handler_id(arg0 int32, arg1 int32)

func (self *CommandNode) RequireWithHandlerId(handlerId uint32) {

	wasm_import_method_command_node_require_with_handler_id((self).Handle(), int32(handlerId))

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [constructor]command
func wasm_import_constructor_command(arg0 uintptr, arg1 uint32, arg2 uintptr, arg3 uint32) int32

func MakeCommand(names []string, description string) *Command {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	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)))

	}

	utf80 := unsafe.Pointer(unsafe.StringData(description))
	pinner.Pin(utf80)
	result1 := wasm_import_constructor_command(uintptr(result), length, uintptr(utf80), uint32(len(description)))
	return CommandFromOwnHandle(int32(uintptr(result1)))

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command.then
func wasm_import_method_command_then(arg0 int32, arg1 int32)

func (self *Command) Then(node *CommandNode) {

	wasm_import_method_command_then((self).Handle(), (node).TakeHandle())

}

//go:wasmimport pumpkin:plugin/command@0.1.0 [method]command.execute-with-handler-id
func wasm_import_method_command_execute_with_handler_id(arg0 int32, arg1 int32)

func (self *Command) ExecuteWithHandlerId(handlerId uint32) {

	wasm_import_method_command_execute_with_handler_id((self).Handle(), int32(handlerId))

}