// 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_player

import (
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_common"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_gui"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_permission"
	"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"
	"runtime"
	"unsafe"
)

type Hand = pumpkin_plugin_common.Hand
type ItemStack = pumpkin_plugin_common.ItemStack
type Position = witTypes.Tuple3[float64, float64, float64]
type GameMode = pumpkin_plugin_common.GameMode
type World = pumpkin_plugin_world.World
type Entity = pumpkin_plugin_world.Entity
type PermissionLevel = pumpkin_plugin_permission.PermissionLevel
type TextComponent = pumpkin_plugin_text.TextComponent
type Gui = pumpkin_plugin_gui.Gui

// Various abilities a player can have.
type PlayerAbilities struct {
	// Whether the player is invulnerable to damage.
	Invulnerable bool
	// Whether the player is currently flying.
	Flying bool
	// Whether the player is allowed to fly.
	AllowFlying bool
	// Whether the player is in creative mode.
	Creative bool
	// Whether the player can modify the world.
	AllowModifyWorld bool
	// The speed at which the player flies.
	FlySpeed float32
	// The speed at which the player walks.
	WalkSpeed float32
}

// Represents a player's skin textures and metadata.
type PlayerSkin struct {
	// The base64-encoded texture data (usually JSON containing skin/cape URLs).
	Value string
	// The optional signature for the texture data.
	Signature witTypes.Option[string]
}

const (
	SkinPartsCape          uint8 = 1 << 0
	SkinPartsJacket        uint8 = 1 << 1
	SkinPartsLeftSleeve    uint8 = 1 << 2
	SkinPartsRightSleeve   uint8 = 1 << 3
	SkinPartsLeftPantsLeg  uint8 = 1 << 4
	SkinPartsRightPantsLeg uint8 = 1 << 5
	SkinPartsHat           uint8 = 1 << 6
)

// Flags representing visible skin parts.
type SkinParts = uint8

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

// A handle to a player on the server.
type Player struct {
	handle *witRuntime.Handle
}

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

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

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

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

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

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

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.as-entity
func wasm_import_method_player_as_entity(arg0 int32) int32

func (self *Player) AsEntity() *pumpkin_plugin_world.Entity {

	result := wasm_import_method_player_as_entity((self).Handle())
	return pumpkin_plugin_world.EntityFromOwnHandle(int32(uintptr(result)))

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-id
func wasm_import_method_player_get_id(arg0 int32, arg1 uintptr)

func (self *Player) GetId() string {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_player_get_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 pumpkin:plugin/player@0.1.0 [method]player.get-name
func wasm_import_method_player_get_name(arg0 int32, arg1 uintptr)

func (self *Player) GetName() string {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_player_get_name((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 pumpkin:plugin/player@0.1.0 [method]player.get-position
func wasm_import_method_player_get_position(arg0 int32, arg1 uintptr)

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

	returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
	wasm_import_method_player_get_position((self).Handle(), returnArea)
	result := witTypes.Tuple3[float64, float64, float64]{*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 0)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 16))}
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-yaw
func wasm_import_method_player_get_yaw(arg0 int32) float32

func (self *Player) GetYaw() float32 {

	result := wasm_import_method_player_get_yaw((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-pitch
func wasm_import_method_player_get_pitch(arg0 int32) float32

func (self *Player) GetPitch() float32 {

	result := wasm_import_method_player_get_pitch((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-world
func wasm_import_method_player_get_world(arg0 int32) int32

func (self *Player) GetWorld() *pumpkin_plugin_world.World {

	result := wasm_import_method_player_get_world((self).Handle())
	return pumpkin_plugin_world.WorldFromOwnHandle(int32(uintptr(result)))

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-gamemode
func wasm_import_method_player_get_gamemode(arg0 int32) int32

func (self *Player) GetGamemode() pumpkin_plugin_common.GameMode {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-gamemode
func wasm_import_method_player_set_gamemode(arg0 int32, arg1 int32) int32

func (self *Player) SetGamemode(mode pumpkin_plugin_common.GameMode) bool {

	result := wasm_import_method_player_set_gamemode((self).Handle(), int32(mode))
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-locale
func wasm_import_method_player_get_locale(arg0 int32, arg1 uintptr)

func (self *Player) GetLocale() string {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_player_get_locale((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 pumpkin:plugin/player@0.1.0 [method]player.get-ping
func wasm_import_method_player_get_ping(arg0 int32) int32

func (self *Player) GetPing() uint32 {

	result := wasm_import_method_player_get_ping((self).Handle())
	return uint32(result)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-permission-level
func wasm_import_method_player_get_permission_level(arg0 int32) int32

func (self *Player) GetPermissionLevel() pumpkin_plugin_permission.PermissionLevel {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-permission-level
func wasm_import_method_player_set_permission_level(arg0 int32, arg1 int32)

func (self *Player) SetPermissionLevel(level pumpkin_plugin_permission.PermissionLevel) {

	wasm_import_method_player_set_permission_level((self).Handle(), int32(level))

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-permission
func wasm_import_method_player_set_permission(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32)

func (self *Player) SetPermission(node string, value bool) {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(node))
	pinner.Pin(utf8)
	var result int32
	if value {
		result = 1
	} else {
		result = 0
	}
	wasm_import_method_player_set_permission((self).Handle(), uintptr(utf8), uint32(len(node)), result)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.unset-permission
func wasm_import_method_player_unset_permission(arg0 int32, arg1 uintptr, arg2 uint32)

func (self *Player) UnsetPermission(node string) {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(node))
	pinner.Pin(utf8)
	wasm_import_method_player_unset_permission((self).Handle(), uintptr(utf8), uint32(len(node)))

}

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

func (self *Player) HasPermissionSet(node string) witTypes.Option[bool] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 2, 1))
	utf8 := unsafe.Pointer(unsafe.StringData(node))
	pinner.Pin(utf8)
	wasm_import_method_player_has_permission_set((self).Handle(), uintptr(utf8), uint32(len(node)), returnArea)
	var option witTypes.Option[bool]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[bool]()
	case 1:

		option = witTypes.Some[bool]((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 1))) != 0))
	default:
		panic("unreachable")
	}
	result := option
	return result

}

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

func (self *Player) HasPermission(node string) bool {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-display-name
func wasm_import_method_player_get_display_name(arg0 int32) int32

func (self *Player) GetDisplayName() *pumpkin_plugin_text.TextComponent {

	result := wasm_import_method_player_get_display_name((self).Handle())
	return pumpkin_plugin_text.TextComponentFromOwnHandle(int32(uintptr(result)))

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-display-name
func wasm_import_method_player_set_display_name(arg0 int32, arg1 int32)

func (self *Player) SetDisplayName(displayName *pumpkin_plugin_text.TextComponent) {

	wasm_import_method_player_set_display_name((self).Handle(), (displayName).TakeHandle())

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.send-system-message
func wasm_import_method_player_send_system_message(arg0 int32, arg1 int32, arg2 int32)

func (self *Player) SendSystemMessage(text *pumpkin_plugin_text.TextComponent, overlay bool) {

	var result int32
	if overlay {
		result = 1
	} else {
		result = 0
	}
	wasm_import_method_player_send_system_message((self).Handle(), (text).TakeHandle(), result)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-header-footer
func wasm_import_method_player_set_tab_list_header_footer(arg0 int32, arg1 int32, arg2 int32)

func (self *Player) SetTabListHeaderFooter(header *pumpkin_plugin_text.TextComponent, footer *pumpkin_plugin_text.TextComponent) {

	wasm_import_method_player_set_tab_list_header_footer((self).Handle(), (header).TakeHandle(), (footer).TakeHandle())

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-order
func wasm_import_method_player_set_tab_list_order(arg0 int32, arg1 int32)

func (self *Player) SetTabListOrder(order int32) {

	wasm_import_method_player_set_tab_list_order((self).Handle(), order)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-latency
func wasm_import_method_player_set_tab_list_latency(arg0 int32, arg1 int32)

func (self *Player) SetTabListLatency(latency int32) {

	wasm_import_method_player_set_tab_list_latency((self).Handle(), latency)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-listed
func wasm_import_method_player_set_tab_list_listed(arg0 int32, arg1 int32)

func (self *Player) SetTabListListed(listed bool) {

	var result int32
	if listed {
		result = 1
	} else {
		result = 0
	}
	wasm_import_method_player_set_tab_list_listed((self).Handle(), result)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.show-title
func wasm_import_method_player_show_title(arg0 int32, arg1 int32)

func (self *Player) ShowTitle(text *pumpkin_plugin_text.TextComponent) {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.show-subtitle
func wasm_import_method_player_show_subtitle(arg0 int32, arg1 int32)

func (self *Player) ShowSubtitle(text *pumpkin_plugin_text.TextComponent) {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.show-actionbar
func wasm_import_method_player_show_actionbar(arg0 int32, arg1 int32)

func (self *Player) ShowActionbar(text *pumpkin_plugin_text.TextComponent) {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.send-title-animation
func wasm_import_method_player_send_title_animation(arg0 int32, arg1 int32, arg2 int32, arg3 int32)

func (self *Player) SendTitleAnimation(fadeIn int32, stay int32, fadeOut int32) {

	wasm_import_method_player_send_title_animation((self).Handle(), fadeIn, stay, fadeOut)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.teleport
func wasm_import_method_player_teleport(arg0 int32, arg1 float64, arg2 float64, arg3 float64, arg4 int32, arg5 float32, arg6 int32, arg7 float32, arg8 int32)

func (self *Player) Teleport(position witTypes.Tuple3[float64, float64, float64], yaw witTypes.Option[float32], pitch witTypes.Option[float32], world *pumpkin_plugin_world.World) {

	var option int32
	var option0 float32
	switch yaw.Tag() {
	case witTypes.OptionNone:

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

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

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

		option1 = int32(1)
		option2 = payload
	default:
		panic("unreachable")
	}
	wasm_import_method_player_teleport((self).Handle(), (position).F0, (position).F1, (position).F2, option, option0, option1, option2, (world).TakeHandle())

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.teleport-world
func wasm_import_method_player_teleport_world(arg0 int32, arg1 int32, arg2 float64, arg3 float64, arg4 float64, arg5 int32, arg6 float32, arg7 int32, arg8 float32)

func (self *Player) TeleportWorld(worldRef *pumpkin_plugin_world.World, position witTypes.Tuple3[float64, float64, float64], yaw witTypes.Option[float32], pitch witTypes.Option[float32]) {

	var option int32
	var option0 float32
	switch yaw.Tag() {
	case witTypes.OptionNone:

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

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

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

		option1 = int32(1)
		option2 = payload
	default:
		panic("unreachable")
	}
	wasm_import_method_player_teleport_world((self).Handle(), (worldRef).TakeHandle(), (position).F0, (position).F1, (position).F2, option, option0, option1, option2)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.kick
func wasm_import_method_player_kick(arg0 int32, arg1 int32)

func (self *Player) Kick(message *pumpkin_plugin_text.TextComponent) {

	wasm_import_method_player_kick((self).Handle(), (message).TakeHandle())

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.respawn
func wasm_import_method_player_respawn(arg0 int32)

func (self *Player) Respawn() {

	wasm_import_method_player_respawn((self).Handle())

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.open-gui
func wasm_import_method_player_open_gui(arg0 int32, arg1 int32)

func (self *Player) OpenGui(guiRef *pumpkin_plugin_gui.Gui) {

	wasm_import_method_player_open_gui((self).Handle(), (guiRef).TakeHandle())

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.ban
func wasm_import_method_player_ban(arg0 int32, arg1 int32, arg2 int32)

func (self *Player) Ban(reason witTypes.Option[*pumpkin_plugin_text.TextComponent]) {

	var option int32
	var option0 int32
	switch reason.Tag() {
	case witTypes.OptionNone:

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

		option = int32(1)
		option0 = (payload).TakeHandle()
	default:
		panic("unreachable")
	}
	wasm_import_method_player_ban((self).Handle(), option, option0)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.ban-ip
func wasm_import_method_player_ban_ip(arg0 int32, arg1 int32, arg2 int32)

func (self *Player) BanIp(reason witTypes.Option[*pumpkin_plugin_text.TextComponent]) {

	var option int32
	var option0 int32
	switch reason.Tag() {
	case witTypes.OptionNone:

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

		option = int32(1)
		option0 = (payload).TakeHandle()
	default:
		panic("unreachable")
	}
	wasm_import_method_player_ban_ip((self).Handle(), option, option0)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-selected-slot
func wasm_import_method_player_get_selected_slot(arg0 int32) int32

func (self *Player) GetSelectedSlot() uint8 {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-item-in-hand
func wasm_import_method_player_get_item_in_hand(arg0 int32, arg1 int32, arg2 uintptr)

func (self *Player) GetItemInHand(hand pumpkin_plugin_common.Hand) witTypes.Option[pumpkin_plugin_common.ItemStack] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
	wasm_import_method_player_get_item_in_hand((self).Handle(), int32(hand), returnArea)
	var option witTypes.Option[pumpkin_plugin_common.ItemStack]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[pumpkin_plugin_common.ItemStack]()
	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[pumpkin_plugin_common.ItemStack](pumpkin_plugin_common.ItemStack{value, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))})
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-inventory-item
func wasm_import_method_player_get_inventory_item(arg0 int32, arg1 int32, arg2 uintptr)

func (self *Player) GetInventoryItem(slot uint8) witTypes.Option[pumpkin_plugin_common.ItemStack] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
	wasm_import_method_player_get_inventory_item((self).Handle(), int32(slot), returnArea)
	var option witTypes.Option[pumpkin_plugin_common.ItemStack]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[pumpkin_plugin_common.ItemStack]()
	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[pumpkin_plugin_common.ItemStack](pumpkin_plugin_common.ItemStack{value, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))})
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-health
func wasm_import_method_player_get_health(arg0 int32) float32

func (self *Player) GetHealth() float32 {

	result := wasm_import_method_player_get_health((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-health
func wasm_import_method_player_set_health(arg0 int32, arg1 float32)

func (self *Player) SetHealth(health float32) {

	wasm_import_method_player_set_health((self).Handle(), health)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-max-health
func wasm_import_method_player_get_max_health(arg0 int32) float32

func (self *Player) GetMaxHealth() float32 {

	result := wasm_import_method_player_get_max_health((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-max-health
func wasm_import_method_player_set_max_health(arg0 int32, arg1 float32)

func (self *Player) SetMaxHealth(maxHealth float32) {

	wasm_import_method_player_set_max_health((self).Handle(), maxHealth)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-food-level
func wasm_import_method_player_get_food_level(arg0 int32) int32

func (self *Player) GetFoodLevel() uint8 {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-food-level
func wasm_import_method_player_set_food_level(arg0 int32, arg1 int32)

func (self *Player) SetFoodLevel(foodLevel uint8) {

	wasm_import_method_player_set_food_level((self).Handle(), int32(foodLevel))

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-saturation
func wasm_import_method_player_get_saturation(arg0 int32) float32

func (self *Player) GetSaturation() float32 {

	result := wasm_import_method_player_get_saturation((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-saturation
func wasm_import_method_player_set_saturation(arg0 int32, arg1 float32)

func (self *Player) SetSaturation(saturation float32) {

	wasm_import_method_player_set_saturation((self).Handle(), saturation)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-exhaustion
func wasm_import_method_player_get_exhaustion(arg0 int32) float32

func (self *Player) GetExhaustion() float32 {

	result := wasm_import_method_player_get_exhaustion((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-exhaustion
func wasm_import_method_player_set_exhaustion(arg0 int32, arg1 float32)

func (self *Player) SetExhaustion(exhaustion float32) {

	wasm_import_method_player_set_exhaustion((self).Handle(), exhaustion)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-absorption
func wasm_import_method_player_get_absorption(arg0 int32) float32

func (self *Player) GetAbsorption() float32 {

	result := wasm_import_method_player_get_absorption((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-absorption
func wasm_import_method_player_set_absorption(arg0 int32, arg1 float32)

func (self *Player) SetAbsorption(absorption float32) {

	wasm_import_method_player_set_absorption((self).Handle(), absorption)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-experience-level
func wasm_import_method_player_get_experience_level(arg0 int32) int32

func (self *Player) GetExperienceLevel() int32 {

	result := wasm_import_method_player_get_experience_level((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-experience-progress
func wasm_import_method_player_get_experience_progress(arg0 int32) float32

func (self *Player) GetExperienceProgress() float32 {

	result := wasm_import_method_player_get_experience_progress((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-experience-points
func wasm_import_method_player_get_experience_points(arg0 int32) int32

func (self *Player) GetExperiencePoints() int32 {

	result := wasm_import_method_player_get_experience_points((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-experience-level
func wasm_import_method_player_set_experience_level(arg0 int32, arg1 int32)

func (self *Player) SetExperienceLevel(level int32) {

	wasm_import_method_player_set_experience_level((self).Handle(), level)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-experience-progress
func wasm_import_method_player_set_experience_progress(arg0 int32, arg1 float32)

func (self *Player) SetExperienceProgress(progress float32) {

	wasm_import_method_player_set_experience_progress((self).Handle(), progress)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-experience-points
func wasm_import_method_player_set_experience_points(arg0 int32, arg1 int32)

func (self *Player) SetExperiencePoints(points int32) {

	wasm_import_method_player_set_experience_points((self).Handle(), points)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.add-experience-levels
func wasm_import_method_player_add_experience_levels(arg0 int32, arg1 int32)

func (self *Player) AddExperienceLevels(levels int32) {

	wasm_import_method_player_add_experience_levels((self).Handle(), levels)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.add-experience-points
func wasm_import_method_player_add_experience_points(arg0 int32, arg1 int32)

func (self *Player) AddExperiencePoints(points int32) {

	wasm_import_method_player_add_experience_points((self).Handle(), points)

}

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

func (self *Player) IsFlying() bool {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-flying
func wasm_import_method_player_set_flying(arg0 int32, arg1 int32)

func (self *Player) SetFlying(flying bool) {

	var result int32
	if flying {
		result = 1
	} else {
		result = 0
	}
	wasm_import_method_player_set_flying((self).Handle(), result)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-abilities
func wasm_import_method_player_get_abilities(arg0 int32, arg1 uintptr)

func (self *Player) GetAbilities() PlayerAbilities {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 16, 4))
	wasm_import_method_player_get_abilities((self).Handle(), returnArea)
	result := PlayerAbilities{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 1))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 2))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 3))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) != 0), *(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 12))}
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-abilities
func wasm_import_method_player_set_abilities(arg0 int32, arg1 int32, arg2 int32, arg3 int32, arg4 int32, arg5 int32, arg6 float32, arg7 float32)

func (self *Player) SetAbilities(abilities PlayerAbilities) {

	var result int32
	if (abilities).Invulnerable {
		result = 1
	} else {
		result = 0
	}
	var result0 int32
	if (abilities).Flying {
		result0 = 1
	} else {
		result0 = 0
	}
	var result1 int32
	if (abilities).AllowFlying {
		result1 = 1
	} else {
		result1 = 0
	}
	var result2 int32
	if (abilities).Creative {
		result2 = 1
	} else {
		result2 = 0
	}
	var result3 int32
	if (abilities).AllowModifyWorld {
		result3 = 1
	} else {
		result3 = 0
	}
	wasm_import_method_player_set_abilities((self).Handle(), result, result0, result1, result2, result3, (abilities).FlySpeed, (abilities).WalkSpeed)

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-ip
func wasm_import_method_player_get_ip(arg0 int32, arg1 uintptr)

func (self *Player) GetIp() string {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_player_get_ip((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 pumpkin:plugin/player@0.1.0 [method]player.get-skin
func wasm_import_method_player_get_skin(arg0 int32, arg1 uintptr)

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

	returnArea := uintptr(witRuntime.Allocate(pinner, (6 * 4), 4))
	wasm_import_method_player_get_skin((self).Handle(), returnArea)
	var option1 witTypes.Option[PlayerSkin]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option1 = witTypes.None[PlayerSkin]()
	case 1:
		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
		var option witTypes.Option[string]
		switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) {
		case 0:

			option = witTypes.None[string]()
		case 1:
			value0 := 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[string](value0)
		default:
			panic("unreachable")
		}

		option1 = witTypes.Some[PlayerSkin](PlayerSkin{value, option})
	default:
		panic("unreachable")
	}
	result := option1
	return result

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-skin-parts
func wasm_import_method_player_get_skin_parts(arg0 int32) int32

func (self *Player) GetSkinParts() SkinParts {

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

}

//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-skin-parts
func wasm_import_method_player_set_skin_parts(arg0 int32, arg1 int32)

func (self *Player) SetSkinParts(parts SkinParts) {

	wasm_import_method_player_set_skin_parts((self).Handle(), int32(parts))

}