Fortnite Verse Digests: Release-24.20-CL-25058254

Fortnite.digest.verse

# Copyright Epic Games, Inc. All Rights Reserved.
#################################################
# Generated Digest of Verse API
# DO NOT modify this manually!
# Generated from build: ++Fortnite+Release-24.20-CL-25058254
#################################################

using {/Verse.org/Colors}
using {/UnrealEngine.com/Temporary/SpatialMath}
using {/Fortnite.com/Playspaces}
using {/UnrealEngine.com/Temporary/UI}
# Module import path: /Fortnite.com/UI
UI<public> := module:
    # Button with text message common base class. Displays a button with a custom message string.
    text_button_base<native><public> := class<abstract><epic_internal>(widget):
        # The text to display to the user. Used only during initialization of the widget and not modified by SetText.
        DefaultText<localizes><native><public>:message = external {}

        # Subscribable event that fires when the button is clicked.
        OnClick<public>():listenable(widget_message) = external {}

        # Sets the text displayed in the widget.
        SetText<native><public>(InText:message):void

        # Gets the text currently in the widget.
        GetText<native><public>():[]char

    # Text button with big and loud styling applied.
    button_loud<native><public> := class<final>(text_button_base):

    # Text button with normal styling applied.
    button_regular<native><public> := class<final>(text_button_base):

    # Text button with quiet styling applied.
    button_quiet<native><public> := class<final>(text_button_base):

    # Deprecated. This function affects all players. Please use `fort_playspace.GetHUDController().ShowElements()`.
    # Shows a set of HUD elements.
    (PlayerUI:player_ui).ShowHUDElements<native><public>(HUDElements:[]hud_element_identifier):void

    # Deprecated. This function affects all players. Please use `fort_playspace.GetHUDController().HideElements()`.
    # Hides a set of HUD elements.
    (PlayerUI:player_ui).HideHUDElements<native><public>(HUDElements:[]hud_element_identifier):void

    # Deprecated. This function affects all players. Please use `fort_playspace.GetHUDController().ResetElementVisibility()`.
    # Resets the visibility for a set of HUD elements.
    (PlayerUI:player_ui).ResetHUDElementVisibility<native><public>(HUDElements:[]hud_element_identifier):void

    # A HUD controller that allows for showing and hiding of HUD elements.
    fort_hud_controller<native><public> := interface:
        # Shows a set of HUD elements.
        ShowElements<public>(HUDElements:[]hud_element_identifier):void

        # Hides a set of HUD elements.
        HideElements<public>(HUDElements:[]hud_element_identifier):void

        # Resets the visibility for a set of HUD elements.
        ResetElementVisibility<public>(HUDElements:[]hud_element_identifier):void

    # Get the `fort_hud_controller` for the current `fort_playspace`.
    (Playspace:fort_playspace).GetHUDController<native><public>():fort_hud_controller

    creative_hud_identifier_all<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_build_menu<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_crafting_resources<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_elimination_counter<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_equipped_item<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_experience_level<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_experience_supercharged<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_experience_ui<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_health<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_health_numbers<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_hud_info<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_interaction_prompts<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_map_prompts<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_mimimap<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_pickup_stream<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_player_count<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_player_inventory<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_round_info<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_round_timer<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_shield_numbers<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_shileds<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_storm_notifications<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_storm_timer<public> := class<final>(hud_element_identifier):

    creative_hud_identifier_team_info<public> := class<final>(hud_element_identifier):

    player_hud_identifier_all<public> := class<final>(hud_element_identifier):

    hud_identifier_world_resource_wood<public> := class<final>(hud_element_identifier):

    hud_identifier_world_resource_stone<public> := class<final>(hud_element_identifier):

    hud_identifier_world_resource_metal<public> := class<final>(hud_element_identifier):

    hud_identifier_world_resource_permanite<public> := class<final>(hud_element_identifier):

    hud_identifier_world_resource_gold_currency<public> := class<final>(hud_element_identifier):

    hud_identifier_world_resource_ingredient<public> := class<final>(hud_element_identifier):

    # Used to identify a HUD element.
    hud_element_identifier<native><public> := class<abstract><epic_internal>:

    # Slider with a text value. Displays a slider, its progress bar and value.
    slider_regular<native><public> := class<final>(widget):
        # The value to display to the user. Used only during initialization of the widget and not modified by SetValue.
        DefaultValue<native><public>:float = external {}

        # The minimum value that the slider can haver. Used only during initialization of the widget and not modified by SetMinValue.
        DefaultMinValue<native><public>:float = external {}

        # The maximum value that the slider can haver. Used only during initialization of the widget and not modified by SetMaxValue.
        DefaultMaxValue<native><public>:float = external {}

        # The amount to adjust the value by, when using a controller or keyboard. Used only during initialization of the widget and not modified by SetStepSize.
        DefaultStepSize<native><public>:float = external {}

        # Sets the value of the slider.
        SetValue<native><public>(InValue:float):void

        # Gets the value of the slider.
        GetValue<native><public>():float

        # Sets the minimum value of the slider.
        SetMinValue<native><public>(InMinValue:float):void

        # Gets the minimum value of the slider.
        GetMinValue<native><public>():float

        # Sets the maximum value of the slider.
        SetMaxValue<native><public>(InMaxValue:float):void

        # Gets the maximum value of the slider.
        GetMaxValue<native><public>():float

        # Sets the amount to adjust the value by, when using a controller or keyboard.
        SetStepSize<native><public>(InValue:float):void

        # Gets the amount to adjust the value by.
        GetStepSize<native><public>():float

        # Subscribable event that fires when the value of the slider has changed.
        OnValueChanged<public>():listenable(widget_message) = external {}

    # Text block widget. Displays text to the user.
    text_block<native><public> := class<final>(text_base):
        # The direction the shadow is cast. Used only during initialization of the widget and not modified by SetShadowOffset.
        DefaultShadowOffset<native><public>:?vector2 = external {}

        # The color of the shadow. Used only during initialization of the widget and not modified by SetShadowColor.
        DefaultShadowColor<native><public>:color = external {}

        # Sets the direction the shadow is cast.
        SetShadowOffset<native><public>(InShadowOffset:?vector2):void

        # Gets the direction the shadow is cast.
        GetShadowOffset<native><public>():?vector2

        # Sets the color of the shadow.
        SetShadowColor<native><public>(InColor:color):void

        # Gets the color of the shadow.
        GetShadowColor<native><public>():color

        # Sets the opacity of the shadow.
        SetShadowOpacity<native><public>(InOpacity:type {_X:float where 0.000000 <= _X, _X <= 1.000000}):void

        # Gets the opacity of the shadow.
        GetShadowOpacity<native><public>():type {_X:float where 0.000000 <= _X, _X <= 1.000000}

using {/Fortnite.com/Game}
using {/Verse.org/Simulation/Tags}
# Module import path: /Fortnite.com/Devices
Devices<public> := module:
    # Module import path: /Fortnite.com/Devices/Animation
    Animation<public> := module:

    # Module import path: /Fortnite.com/Devices/CreativeAnimation
    CreativeAnimation<public> := module:
        # A structure for defining Bezier interpolation parameters.
        # See https://en.wikipedia.org/wiki/B%C3%A9zier_curve for more info on Bezier curves.
        cubic_bezier_parameters<native><public> := struct<computes>:
            # X value of the P1 control point. `0.0 <= X0 <= 1.0` or an error will be generated when
            # calling `animation_controller.SetAnimation`.
            X0<native><public>:float = external {}

            # Y value of the P1 control point.
            Y0<native><public>:float = external {}

            # X value of the P2 control point. `0.0 <= X1 <= 1.0 or an error will be generated when
            # calling `animation_controller.SetAnimation`.
            X1<native><public>:float = external {}

            # Y value of the P2 control point.
            Y1<native><public>:float = external {}

        # Module import path: /Fortnite.com/Devices/CreativeAnimation/InterpolationTypes
        # Convenience interpolation modes. These built in modes are based on the CSS animation standard:
        # https://www.w3.org/TR/css-easing-1/
        InterpolationTypes<public> := module:
            # `Linear` animations move at a constant speed.
            Linear<public>:cubic_bezier_parameters = external {}

            # `Ease` animations start slowly, speed up, then end slowly. The speed of the animation is slightly slower
            # at the end than the start.
            Ease<public>:cubic_bezier_parameters = external {}

            # `EaseIn` animations start slow, then speed up towards the end.
            EaseIn<public>:cubic_bezier_parameters = external {}

            # `EaseOut` animations start fast, then slow down towards the end.
            EaseOut<public>:cubic_bezier_parameters = external {}

            # `EaseInOut` animations are similar to `Ease` but the start and end animation speed is symmetric.
            EaseInOut<public>:cubic_bezier_parameters = external {}

        # Instead of specifying the actual keyframe positions, we specify the keyframe *deltas*. This allows us to
        # treat the initial position of the prop as keyframe 0 and avoid the question of how to get the prop to its
        # initial location. For a `animation_mode.Loop` animation, the net rotation and translation must both be zero.
        # Each delta is interpreted as a world-space transformation to be concatenated onto the previous transform(s).
        keyframe_delta<native><public> := struct:
            # Target position of the `creative_prop`. This is a world-space coordinate in cm, with the
            # initial position of the `creative_prop` acting as coordinate (0,0).
            DeltaLocation<native><public>:vector3

            # Target rotation for the `creative_prop`. Rotations are relative to the starting rotation of
            # the `creative_prop`
            DeltaRotation<native><public>:rotation

            # Time in seconds the `creative_prop` should animate between its last frame and this frame.
            Time<native><public>:float

            # Interpolation mode for this `keyframe_delta`. See `InterpolationTypes` for standard interpolation
            # options. See `cubic_bezier_parameters` for authoring custom interpolations.
            # 
            # Default = `InterpolationTypes.Linear`
            Interpolation<native><public>:cubic_bezier_parameters = external {}

        # Animation play modes.
        animation_mode<native><public> := enum:
            # Stop after playing the animation once.
            OneShot
            # Reverse direction after reaching the final `keyframe_delta`, then play the animation in reverse.
            PingPong
            # Play the animation in a loop. This requires the animation ends exactly where it began.
            Loop

        # `animation_controller` states.
        animation_controller_state<native><public> := enum:
            # The target of the animation is not an animatable prop. This could be because:
            #  * It is not a `creative_prop` that can be animated.
            #  * It was disposed or otherwise destroyed.
            #  * It has the 'Register with Structural Grid' option set in UEFN.
            InvalidObject
            # No animation has been successfully set via `animation_controller.SetAnimation`, or that animation has
            # been cleared by a failed call to `animation_controller.SetAnimation`.
            AnimationNotSet
            # Animation has either never started, finished, or was explicitly stopped.
            Stopped
            # Animation is playing.
            Playing
            # Animation is paused.
            Paused

        # Results for `animation_controller.AwaitNextKeyframe` function.
        await_next_keyframe_result<native><public> := enum:
            # The next keyframe has been reached successfully.
            KeyframeReached
            # No animation is currently playing and this function call has returned immediately.
            NotPlaying
            # The animation was canceled either due to the object being destroyed, becoming invalid, or because it
            # was moved via some other API.
            AnimationAborted

        # Used to move and animate the position of `creative_prop` objects.
        #  * See `creative_prop.GetAnimationController` for information on acquiring an instance of an
        #    `animation_controller` for a given `creative_prop`.
        #  * See `SetAnimation` for details on authoring movement and animations.
        animation_controller<native><public> := class<epic_internal>:
            # Suspends at the callsite until the next `keyframe_delta` is finished. This will also return if the
            # animation is aborted or not playing. See `await_next_keyframe_result` if your code needs to take
            # different paths based on why `AwaitNextKeyframe` returned.
            AwaitNextKeyframe<native><public>()<suspends>:await_next_keyframe_result

            # Starts or resumes playback of the animation.
            Play<public>():void = external {}

            # Pauses the animation if it is already playing.
            Pause<public>():void = external {}

            # Stops playback and resets the animation to the first keyframe. Also resets the prop transform. Calling 
            # this method is valid while the animation is in the `Playing` or `Paused` states.
            Stop<public>():void = external {}

            # Returns the current state of this `animation_controller`.
            GetState<native><public>()<transacts>:animation_controller_state

            # Succeeds if this `animation_controller`s target is still valid (i.e., the target has not been disposed
            # of either via `Dispose` or through any external system.)
            IsValid<native><public>()<transacts><decides>:void

            # Sets the animation for the `animation_controller`. Animations are processed in the order provided in
            # `Keyframes`. See notes in `keyframe_delta` and `animation_mode` for more details on controlling the
            # animations.
            SetAnimation<public>(Keyframes:[]keyframe_delta, ?Mode:animation_mode):void = external {}

            # Signaled each time a keyframe is reached. Callback(KeyframeIndex:int, InReverse:logic). Note that the
            # KeyframeIndex in the callback is generally in [1, NumDeltaKeyframes] except that in a PingPong animation
            # the final keyframe played in reverse is identified as index 0. This is because SetAnimation takes *delta*
            # keyframes whereas this event notifies the listener that a specific keyframe has been reached.
            KeyframeReachedEvent<native><public>:subscribable(tuple(int, logic)) = external {}

            # Signaled when the entire animation is complete. This will only fire for `OneShot` animations.
            MovementCompleteEvent<native><public>:subscribable(tuple()) = external {}

            # Signaled when the state has changed. Use `GetState` to get the new state.
            StateChangedEvent<native><public>:subscribable(tuple()) = external {}

        # Returns an `animation_controller` used to animate `Prop`. Only a subset of `creative_prop` types can be
        # animated, though this may change in the future. A few examples of props that cannot be animated yet are:
        #  * Walls attached to buildings
        #  * Treasure chests
        #  * Loot llamas
        (Prop:creative_prop).GetAnimationController<public>()<transacts><decides>:animation_controller = external {}

    # Inherit from this to create a custom creative device. Inherited classes will appear in the UEFN content
    # browser the next time Verse compiles. Instances of your derived `creative_device` can then be placed in the
    # island by dragging them from the content browser into the scene.
    creative_device<native><public> := class<concrete>(creative_object_interface):
        # Override to add custom logic when the game experience begins.
        OnBegin<public>()<suspends>:void = external {}

        # Override to add custom logic when the game experience ends. Any coroutines spawned inside `OnEnd` may never execute.
        OnEnd<native_callable><public>():void = external {}

        # Returns the transform of the `creative_device` with units in cm.
        GetTransform<override><native>()<transacts>:transform

    # Returns an array containing all creative objects which have been marked with the specified `Tag`.
    GetCreativeObjectsWithTag<native><public>(Tag:tag)<transacts>:[]creative_object_interface

    # Returns an array containing creative objects which have tag(s) matching the specified `SearchCriteria`.
    GetCreativeObjectsWithTags<native><public>(SearchCriteria:tag_search_criteria)<transacts>:[]creative_object_interface

    # Returns a queryable `tag_view` which can be used to query the tags on `CreativeObject`.
    (CreativeObject:creative_object_interface).GetTags<native><public>():tag_view

    # Returns the `fort_playspace` that `CreativeObject` belongs to.
    (CreativeObject:creative_object_interface).GetPlayspace<native><public>()<transacts>:fort_playspace

    creative_object_interface<native><public> := interface<epic_internal>(positional):

    # Base class for creative devices and props.
    creative_object<native><public> := class<epic_internal>(creative_object_interface):
        # Returns the transform of the `creative_object` with units in cm. You must check `creative_object.IsValid`
        # before calling this if there is a possibility the object has been disposed or destroyed by gameplay.
        # Otherwise a runtime error will result.
        GetTransform<override><native>()<transacts>:transform

    # Base class for creative_device.
    creative_device_base<native><public> := class<abstract><epic_internal>(creative_object):

    # Results for `creative_prop.MoveTo`.
    move_to_result<public> := enum:
        # The destination has been reached.
        DestinationReached
        # The destination will not be reached. See debug log in UEFN for more info.
        WillNotReachDestination

    # Results for `SpawnProp`.
    spawn_prop_result<native><public> := enum:
        # Success.
        Ok
        # An unknown error occurred. If this happens frequently, contact Epic support.
        UnknownError
        # The spawn point contains NaN or Inf.
        InvalidSpawnPoint
        # The spawn point is outside the island's boundaries.
        SpawnPointOutOfBounds
        # The asset is not a valid `creative_prop`.
        InvalidAsset
        # More props have been spawned than are permitted by the island's rules (currently 100 per script device and 200 total per island).
        TooManyProps

    # A Fortnite prop that has been placed or spawned in the island.
    creative_prop<native><public> := class<concrete><final>(creative_object, invalidatable):
        # Teleport the `creative_prop` to the specified `Position` and `Rotation`.
        TeleportTo<public>(Position:vector3, Rotation:rotation)<transacts><decides>:void = external {}

        # Destroy the `creative_prop` and remove it from the island.
        Dispose<native><override>():void

        # Succeeds if this object has not been disposed of either via `Dispose()` or through an external system.
        IsValid<native><override>()<transacts><decides>:void

        # Move the `creative_prop` to the specified `Position` and `Rotation` over the specified time. If an animation
        # is currently playing on the `creative_prop` it will be stopped and put into the `AnimationNotSet` state.
        MoveTo<public>(Position:vector3, Rotation:rotation, OverTime:float)<suspends>:move_to_result = external {}

    # Asset used to spawn `creative_device` instances.
    creative_device_asset<native><public> := class<computes><final><epic_internal>:

    # Asset used to spawn `creative_prop` instances.
    creative_prop_asset<native><public> := class<computes><concrete><final><epic_internal>:

    # A default asset to be used when creating an editor-specified `creative_prop_asset` variable.
    DefaultCreativePropAsset<public>:creative_prop_asset = external {}

    # Spawns a `creative_prop` at the specified `Position` and `Rotation`. `Position` and `Rotation` units are in cm.
    # Returns tuple:
    #  0: Instance of a `creative_prop`. False if no `creative_prop` could be created. See `spawn_prop_result` for failure cases.
    #  1: Success or failure results.
    SpawnProp<native><public>(Asset:creative_prop_asset, Position:vector3, Rotation:rotation)<transacts>:tuple(?creative_prop, spawn_prop_result)
    using {/Verse.org/Simulation}
    # Used to trigger a visual effect (a glow or an outline) when `agent`s pick it up.
    visual_effect_powerup_device<public> := class<concrete><final>(powerup_device):

    # Holds and spawns items, with an optional cost for each item. Can hold up to three items, and `agent`s can cycle
    # between these by hitting the machine with their pickaxe.
    vending_machine_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an item is spawned from this device.
        # Sends the `agent` that used this device.
        ItemSpawnedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Cycles the screen to show the next item.
        CycleToNextItem<public>():void = external {}

        # Spawns an item.
        SpawnItem<public>():void = external {}

    # Used to relay events to other linked devices.
    trigger_device<public> := class<concrete><final>(trigger_base_device):
        # Signaled when an `agent` triggers this device.
        # Sends the `agent` that used this device. Returns `false` if no `agent` triggered the action
        # (ex: it was triggered through code).
        TriggeredEvent<public>:listenable(?agent) = external {}

        # Triggers this device with `Agent` being passed as the `agent` that triggered the action. Use an `agent`
        # reference when this device is setup to require one (for instance, you want to trigger the device only
        # with a particular `agent`.
        Trigger<public>(Agent:agent):void = external {}

        # Triggers this device, causing it to activate its `TriggeredEvent` event.
        Trigger<public>():void = external {}

    # Base class for various specialized trigger devices. See also:
    #  * `trigger_device`
    #  * `perception_trigger_device`
    #  * `attribute_evaluator_device`
    trigger_base_device<public> := class<abstract><epic_internal>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets the number of times this device has been activated. This will set 
        # `GetTriggerCountRemaining` back to `0`
        Reset<public>():void = external {}

        # Sets the maximum amount of times this device can trigger.
        #  * `0` can be used to indicate no limit on trigger count.
        #  * `MaxCount` is clamped between [0,20].
        SetMaxTriggerCount<public>(MaxCount:int):void = external {}

        # Gets the maximum amount of times this device can trigger.
        #  * `0` indicates no limit on trigger count.
        GetMaxTriggerCount<public>()<transacts>:int = external {}

        # Returns the number of times that this device can still be triggered before hitting `GetMaxTriggerCount`.
        # Returns `0` if `GetMaxTriggerCount` is unlimited.
        GetTriggerCountRemaining<public>()<transacts>:int = external {}

        # Sets the time (in seconds) after triggering, before the device can be triggered again (if `MaxTrigger`
        # count allows).
        SetResetDelay<public>(Time:float):void = external {}

        # Gets the time (in seconds) before the device can be triggered again (if `MaxTrigger` count allows).
        GetResetDelay<public>()<transacts>:float = external {}

        # Sets the time (in seconds) which must pass after triggering, before this device informs other external
        # devices that it has been triggered.
        SetTransmitDelay<public>(Time:float):void = external {}

        # Gets the time (in seconds) which must pass after triggering, before this device informs other external
        # devices that it has been triggered.
        GetTransmitDelay<public>()<transacts>:float = external {}

    # A trap device that destroys the tile it's placed on when activated.
    trick_tile_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the tile this device is attached to is removed. This may occur later than `TriggeredEvent` if 
        # *Activation Delay* is set on the device.
        # Sends the `agent` that activated this device.
        ActivatedEvent<public>:listenable(agent) = external {}

        # Signaled when this device is triggered.
        # Sends the `agent` that triggered this device.
        TriggeredEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device. While disabled this device will not react to incoming events.
        Disable<public>():void = external {}

        # Flips the device between `Enabled` and `Disable`.
        ToggleEnabled<public>():void = external {}

        # Restores the tile removed when this device was triggered.
        Reset<public>():void = external {}

        # Enables this device to trigger when an `agent` makes contact with the device.
        EnableAgentContactTrigger<public>():void = external {}

        # Disables this device from triggering when an `agent` makes contact with the device.
        DisableAgentContactTrigger<public>():void = external {}

        # Flips the device between `EnableAgentContactTrigger` and `DisableAgentContactTrigger.
        ToggleAgentContactTrigger<public>():void = external {}

        # Triggers the device, removing the associated tile.
        Trigger<public>():void = external {}

    # Allows creation and HUD tracking of custom objectives for `agent`s to complete.
    tracker_device<public> := class<concrete><final>(creative_device_base):
        # Resets the progress for `Agent` (and any `agent`s sharing progress).
        Reset<public>(Agent:agent):void = external {}

        # Signaled when the tracked value reaches `GetTarget` for an `agent`.
        # Sends the `agent` that reached `GetTarget` for their tracked value.
        CompleteEvent<public>:listenable(agent) = external {}

        # Assigns the device to `Agent` (and any `agent`s sharing progress).
        Assign<public>(Agent:agent):void = external {}

        # Assigns this device to all valid `agent`s.
        AssignToAll<public>():void = external {}

        # Removes this device from `Agent` (and any `agent`s sharing progress).
        Remove<public>(Agent:agent):void = external {}

        # Removes this device from all valid `agent`s.
        RemoveFromAll<public>():void = external {}

        # The objective immediately completes.
        Complete<public>(Agent:agent):void = external {}

        # Increases the tracked value by *Amount to Change on Received Signal* for `Agent`.
        Increment<public>(Agent:agent):void = external {}

        # Decrease the tracked value by *Amount to Change on Received Signal* for `Agent`.
        Decrement<public>(Agent:agent):void = external {}

        # Increases the target value for `Agent` by 1.
        IncreaseTargetValue<public>(Agent:agent):void = external {}

        # Decreases the target value for `Agent` by 1.
        DecreaseTargetValue<public>(Agent:agent):void = external {}

        # Saves tracked progress for `Agent`. Only valid if *Use Persistence* is set to *Use*.
        Save<public>(Agent:agent):void = external {}

        # Loads tracked progress for `Agent`. Only valid if *Use Persistence* is set to *Use*.
        Load<public>(Agent:agent):void = external {}

        # Loads tracked progress for all valid `agent`s. Only valid if *Use Persistence* is set to *Use*.
        LoadForAll<public>():void = external {}

        # Clears tracked progress for `Agent`. Only valid if *Use Persistence* is set to *Use*.
        ClearPersistence<public>(Agent:agent):void = external {}

        # Sets a description for the `tracker_device`, which is displayed if *Show on HUD* is enabled.
        # `Text` has a 64 character limit.
        SetDescriptionText<public>(Text:message):void = external {}

        # Sets the target value that must be achieved in order for `CompleteEvent` to trigger.
        # Clamped to `0 <= TargetValue <= 10000`.
        SetTarget<public>(TargetValue:int):void = external {}

        # Returns the target value that must be achieved in order for `CompleteEvent` to trigger.
        # Clamped to `0 <= GetTarget <= 10000`.
        GetTarget<public>()<transacts>:int = external {}

        # Sets the title for the `tracker_device`, which is displayed if *Show on HUD* is enabled.
        # `Text` has a 32 character limit.
        SetTitleText<public>(Text:message):void = external {}

    # Provides a way to keep track of the time something has taken, either for scoreboard purposes, or to trigger
    # actions. It can be configured in several ways, either acting as a countdown to an event that is triggered at
    # the end, or as a stopwatch for an action that needs to be completed before a set time runs out.
    timer_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the timer completes or ends with success.
        # Sends the `agent` that activated the timer, if any.
        SuccessEvent<public>:listenable(?agent) = external {}

        # Signaled when the timer completes or ends with failure.
        # Sends the `agent` that activated the timer, if any.
        FailureEvent<public>:listenable(?agent) = external {}

        # Signaled when the timer enters *Urgency Mode*.
        # Sends the `agent` that activated the timer, if any.
        StartUrgencyModeEvent<public>:listenable(?agent) = external {}

        # Enables this device for `Agent`.
        Enable<public>(Agent:agent):void = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device for `Agent`. While disabled this device will not receive signals.
        Disable<public>(Agent:agent):void = external {}

        # Disables this device. While disabled this device will not receive signals.
        Disable<public>():void = external {}

        # Resets the timer back to its base time and stops it for `Agent`.
        Reset<public>(Agent:agent):void = external {}

        # Resets the timer back to its base time and stops it.
        Reset<public>():void = external {}

        # Resets the timer back to its base time and stops it for all `agent`s.
        ResetForAll<public>(Agent:agent):void = external {}

        # Resets the timer back to its base time and stops it for all `agent`s.
        ResetForAll<public>():void = external {}

        # Starts the timer for `Agent`.
        Start<public>(Agent:agent):void = external {}

        # Starts the timer.
        Start<public>():void = external {}

        # Pauses the timer for `Agent`.
        Pause<public>(Agent:agent):void = external {}

        # Pauses the timer.
        Pause<public>():void = external {}

        # Resumes the timer for `Agent`.
        Resume<public>(Agent:agent):void = external {}

        # Resumes the timer.
        Resume<public>():void = external {}

        # Completes the timer for `Agent`.
        Complete<public>(Agent:agent):void = external {}

        # Completes the timer.
        Complete<public>():void = external {}

        # Starts the timer for all `agent`s.
        StartForAll<public>(Agent:agent):void = external {}

        # Starts the timer for all `agent`s.
        StartForAll<public>():void = external {}

        # Pauses the timer for all `agent`s.
        PauseForAll<public>(Agent:agent):void = external {}

        # Pauses the timer for all `agent`s.
        PauseForAll<public>():void = external {}

        # Resumes the timer for all `agent`s.
        ResumeForAll<public>(Agent:agent):void = external {}

        # Resumes the timer for all `agent`s.
        ResumeForAll<public>():void = external {}

        # Completes the timer for all `agent`s.
        CompleteForAll<public>(Agent:agent):void = external {}

        # Completes the timer for all `agent`s.
        CompleteForAll<public>():void = external {}

        # Saves this device's data for `Agent`.
        Save<public>(Agent:agent):void = external {}

        # Loads this device's saved data for `Agent`.
        Load<public>(Agent:agent):void = external {}

        # Clears this device's saved data for `Agent`.
        ClearPersistenceData<public>(Agent:agent):void = external {}

        # Clears this device's saved data for all `agent`s.
        ClearPersistenceDataForAll<public>(Agent:agent):void = external {}

        # Clears this device's saved data for all `agent`s.
        ClearPersistenceDataForAll<public>():void = external {}

        # Sets the remaining time (in seconds) on the timer, if active, on `Agent`.
        SetActiveDuration<public>(Time:float, Agent:agent):void = external {}

        # Sets the remaining time (in seconds) on the timer, if active. Use this function if the timer is set to 
        # use the same time for all `agent`'s.
        SetActiveDuration<public>(Time:float):void = external {}

        # Returns the remaining time (in seconds) on the timer for `Agent`.
        GetActiveDuration<public>(Agent:agent)<transacts>:float = external {}

        # Returns the remaining time (in seconds) on the timer if it is set to be global.
        GetActiveDuration<public>()<transacts>:float = external {}

        # Sets the lap time indicator for `Agent`.
        SetLapTime<public>(Agent:agent):void = external {}

        # Sets the lap time indicator for all `agent`s.
        SetLapTimeForAll<public>(Agent:agent):void = external {}

        # Sets the lap time indicator for all `agent`s.
        SetLapTimeForAll<public>():void = external {}

        # Sets the maximum duration of the timer (in seconds).
        SetMaxDuration<public>(Time:float):void = external {}

        # Returns the maximum duration of the timer (in seconds).
        GetMaxDuration<public>()<transacts>:float = external {}

        # Succeeds if this device is tracking timer state for each individual `agent` independently. Fails if 
        # state is being tracked globally for all `agent`'s.
        IsStatePerAgent<public>()<transacts><decides>:void = external {}

    # Configures game modes where players can start or stop timers to advance gameplay objectives, such as
    # Attack/Defend Bomb objectives.
    timed_objective_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the objective begins.
        # Sends the `agent` that started the timer.
        BeganEvent<public>:listenable(agent) = external {}

        # Signaled when the objective ends.
        # Sends the `agent` that stopped the timer.
        EndedEvent<public>:listenable(agent) = external {}

        # Signaled when the objective is paused.
        # Sends the `agent` that paused the timer.
        PausedEvent<public>:listenable(agent) = external {}

        # Signaled when the objective is resumed.
        # Sends the `agent` that resumed the timer.
        ResumedEvent<public>:listenable(agent) = external {}

        # Signaled when the objective is restarted.
        # Sends the `agent` that restarted the timer.
        RestartedEvent<public>:listenable(agent) = external {}

        # Signaled when the objective is completed.
        # Sends the `agent` that started the timer or completed the timer by calling `Complete`.
        CompletedEvent<public>:listenable(agent) = external {}

        # Enables the objective for `Agent`.
        Enable<public>(Agent:agent):void = external {}

        # Disables the objective for `Agent`.
        Disable<public>(Agent:agent):void = external {}

        # Makes this device visible.
        Show<public>():void = external {}

        # Makes this device invisible.
        Hide<public>():void = external {}

        # Starts the objective with `Agent` acting as the user the interacted this device.
        Begin<public>(Agent:agent):void = external {}

        # Ends the objective with `Agent` acting as the user the interacted this device.
        End<public>(Agent:agent):void = external {}

        # Pauses the objective with `Agent` acting as the user the interacted this device.
        Pause<public>(Agent:agent):void = external {}

        # Resumes the objective with `Agent` acting as the user the interacted this device.
        Resume<public>(Agent:agent):void = external {}

        # Restarts the objective with `Agent` acting as the user the interacted this device.
        Restart<public>(Agent:agent):void = external {}

        # Completes the objective with `Agent` acting as the user the interacted this device.
        Complete<public>(Agent:agent):void = external {}

    # Customizable rift that allows `agent`s to move instantly between locations. You can use this to move players
    # around your island, or create multi-island experiences with teleporters that take players from one island to
    # another.
    teleporter_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` enters this device.
        # Sends the `agent` that entered this device.
        EnterEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` emerges from this device.
        # Sends the `agent` that emerged from this device.
        TeleportedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Teleport `Agent` to the target group using this device.
        Activate<public>(Agent:agent):void = external {}

        # When a link is activated, the current destination teleporter will be able to bring the `agent` back to this
        # origin teleporter. Both origin and destination teleporters need to have this activated to work as expected.
        ActivateLinkToTarget<public>():void = external {}

        # Deactivates any currently active Link. The current destination teleporter will no longer be able to return
        # the agent to this origin teleporter.
        DeactivateLinkToTarget<public>():void = external {}

        # Resets the currently selected destination teleporter, and selects reselects an eligible destination. If the
        # target is a *Teleporter Group*, this may be another randomly chosen `teleporter_device` from that group.
        ResetLinkToTarget<public>():void = external {}

        # Teleport `Agent` to this device.
        Teleport<public>(Agent:agent):void = external {}

    # Provides team and inventory configurations that go beyond the choices the My Island settings provide.
    # Can also be used to customize individual devices and create variations in team setup.
    team_settings_and_inventory_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an enemy of *Team* is eliminated by a team member.
        # Sends the `agent` team member who eliminated the enemy.
        EnemyEliminatedEvent<public>:listenable(agent) = external {}

        # Signaled when a member of *Team* is eliminated.
        # Sends the `agent` that was eliminated.
        TeamMemberEliminatedEvent<public>:listenable(agent) = external {}

        # Signaled when *Team* runs out of respawns.
        TeamOutOfRespawnsEvent<public>:listenable(tuple()) = external {}

        # Ends the round and *Team* wins the round.
        EndRound<public>():void = external {}

    # Used to place the Infinity Blade on your island. When placed, the Infinity Blade
    # becomes available to any player regardless of team affiliation.
    sword_in_the_stone_device<public> := class<concrete><final>(creative_device_base):

    # Used to inform players of other content made by a creator using a Support-A-Creator code. When players activate the device,
    # it will bring up the same Support-A-Creator dialog box they would see in the Creative hub. The Support-A-Creator information
    # shows when the dialog box opens for the player.
    support_a_creator_device<public> := class<concrete><final>(creative_device_base):

    # Base class for various specialized storm devices. See also:
    #  * `basic_storm_controller_device`
    #  * `advanced_storm_controller_device`
    storm_controller_device<public> := class<abstract><epic_internal>(creative_device_base):
        # Signaled when storm resizing ends. Use this with the *On Finish Behavior* option for better controls.
        PhaseEndedEvent<public>:listenable(tuple()) = external {}

        # Generates the storm. *Generate Storm On Game Start* must be set to *No* if you choose to use `GenerateStorm`.
        GenerateStorm<public>():void = external {}

        # Destroys the storm.
        DestroyStorm<public>():void = external {}

    # A set of customizable pop up targets that can be hit by players to trigger various events.
    shooting_range_target_track_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when target is hit in the bullseye area.
        BullseyeHitEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target is hit by a player.
        HitEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target is hit by a player.
        KnockdownEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves up slightly, making it harder to hit.
        HopUpEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves down slightly, making it harder to hit.
        HopDownEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves from laying flat to standing upright.
        PopUpEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves from standing upright to laying flat.
        PopDownEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets the target to its initial settings.
        Reset<public>():void = external {}

        # Moves an active (standing upright) target attached to the track up slightly, in an effort to make it harder to hit
        HopUp<public>():void = external {}

        # Moves an active (standing upright) target attached to the track down slightly, in an effort to make it harder to hit
        HopDown<public>():void = external {}

        # Causes the target attached to the track to transition from lying flat (inactive) to standing upright (active)
        PopUp<public>():void = external {}

        # Causes the target attached to the track to transition from standing upright (active) to lying flat (inactive)
        PopDown<public>():void = external {}

        # Enables movement on the track. This does not start the target moving, it only enables movement.
        EnableTrackMovement<public>():void = external {}

        # Disables movement on the track. This prevents any movement from occurring, until track movement is enabled again.
        DisableTrackMovement<public>():void = external {}

        # Activates the movement track.
        ActivateTrack<public>():void = external {}

        # Deactivates the movement track.
        DeactivateTrack<public>():void = external {}

        # Starts the target moving toward the end of the track.
        MoveToEnd<public>():void = external {}

        # Starts the target moving toward the start of the track.
        MoveToStart<public>():void = external {}

    # A single customizable pop up target that can be hit by `agent`s to trigger various events.
    shooting_range_target_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the target is hit in the bullseye area.
        BullseyeHitEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target is hit by an `agent`.
        HitEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target takes enough damage to get knocked down.
        KnockdownEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves up slightly, making it harder to hit.
        HopUpEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves down slightly, making it harder to hit.
        HopDownEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves from laying flat to standing upright.
        PopUpEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target moves from standing upright to laying flat.
        PopDownEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets the target to its initial settings.
        Reset<public>():void = external {}

        # Moves an active (standing upright) target up slightly, in an effort to make it harder to hit.
        HopUp<public>():void = external {}

        # Moves an active (standing upright) target down slightly, in an effort to make it harder to hit.
        HopDown<public>():void = external {}

        # Causes a target to transition from lying flat (inactive) to standing upright (active).
        PopUp<public>():void = external {}

        # Causes a target to transition from standing upright (active) to lying flat (inactive).
        PopDown<public>():void = external {}

    # Used to manipulate scores using in-experience triggers. If *Activating Team* is set to a specific team, then you 
    # should use the `agent` overloads of each function. The `agent`'s team will be used to determine if that `agent` is
    # allowed to affect the state of the device.
    score_manager_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the this device reaches its maximum number of triggers as defined by *Times Can Trigger*.
        # Sends the `agent` who last tiggered the device.
        MaxTriggersEvent<public>:listenable(agent) = external {}

        # Signaled when the this device awards points to an `agent`.
        # Sends the `agent` who received the points.
        ScoreOutputEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>(Agent:agent):void = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>(Agent:agent):void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets this device to its original state.
        Reset<public>(Agent:agent):void = external {}

        # Resets this device to its original state.
        Reset<public>():void = external {}

        # Grant points to `Agent`.
        Activate<public>(Agent:agent):void = external {}

        # Grants points.
        Activate<public>():void = external {}

        # Increments the score quantity to be awarded by the next activation by `1`.
        Increment<public>(Agent:agent):void = external {}

        # Increments the score quantity to be awarded by the next activation by `1`.
        Increment<public>():void = external {}

        # Decrements the score quantity to be awarded by the next activation by `1`.
        Decrement<public>(Agent:agent):void = external {}

        # Decrements the score quantity to be awarded by the next activation by `1`.
        Decrement<public>():void = external {}

        # Sets the score to be awarded by the next activation to `Value`.
        SetScoreAward<public>(Value:int):void = external {}

        # Returns the score to be awarded by the next activation.
        GetScoreAward<public>()<transacts>:int = external {}

        # Sets the score to be awarded by the next activation to `Agent`'s current score.
        SetToAgentScore<public>(Agent:agent):void = external {}

        # Returns the current score for `Agent`.
        GetCurrentScore<public>(Agent:agent)<transacts>:int = external {}

    # Used to customize gameplay for any round-based game. It generally defines what happens to the
    # `agent`'s inventory and rewards in each round.
    round_settings_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when a game round starts.
        RoundBeginEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Enables the ability for players to Matchmake into the Island. Only applies to published games that have
        # matchmaking turned on in the Island settings
        EnableMatchmaking<public>():void = external {}

        # Disables the ability for players to Matchmake into the Island. Only applies to published games that have
        # matchmaking turned on in the Island settings
        DisableMatchmaking<public>():void = external {}

        # Toggles between `EnableMatchmaking` and `DisableMatchmaking`.
        ToggleMatchmaking<public>():void = external {}

        # Disables all end-round conditions. The round must be ended through calling `EndRound` or a creative event
        # after this is called.
        DisableEndRoundConditions<public>():void = external {}

        # Ends the round immediately with `Agent`'s team set as the winner of the round.
        EndRound<public>(Agent:agent):void = external {}

    # Used to generate random numbers between a minimum and maximum value. Events are signaled when numbers are generated.
    #  * *Value Limit 1* is the minimum value for generation.
    #  * *Value Limit 2* is the maximum value for generation.
    rng_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the generated number >= *Winning Value*.
        WinEvent<public>:listenable(tuple()) = external {}

        # Signaled when the generated number < *Winning Value*.
        LoseEvent<public>:listenable(tuple()) = external {}

        # Signaled when the generated number = maximum.
        RolledMaxEvent<public>:listenable(tuple()) = external {}

        # Signaled when the generated number = minimum.
        RolledMinEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Randomly generate a number between *Value Limit 1* and *Value Limit 2*.
        #  * If the number is >= *Winning Value* then `WinEvent` is fired.
        #  * If the number is < *Winning Value* then `LoseEvent` is fired.
        #  * If the number = minimum then `RolledMinEvent` is fired.
        #  * If the number = maximum then `RolledMaxEvent` is fired.
        #  * `Agent` is used as the Instigator of the roll event.
        Activate<public>(Agent:agent):void = external {}

        # Randomly roll a number within the configured min + max value range.
        #  * If the number is >= *Winning Value* then `WinEvent` is fired.
        #  * If the number is < *Winning Value* then `LoseEvent` is fired.
        #  * If the number = minimum then `RolledMinEvent` is fired.
        #  * If the number = maximum then `RolledMaxEvent` is fired.
        Activate<public>():void = external {}

        # Cancels the active number generation.
        Cancel<public>():void = external {}

    # Used to play curated music from the device or one or more registered `agent`s.
    radio_device<public> := class<concrete><final>(creative_device_base):
        # Starts playing audio from this device.
        Play<public>():void = external {}

        # Stops playing audio from this device.
        Stop<public>():void = external {}

        # Adds the specified agent as a target for the Radio to play audio from
        Register<public>(Agent:agent):void = external {}

        # Removes the specified agent as a target for the Radio to play audio from if previously Registered
        Unregister<public>(Agent:agent):void = external {}

        # Removes all previously registered agents as targets for the Radio to play audio from
        UnregisterAll<public>():void = external {}

    # A device used to damage players who collide with it. Can also be used as a trigger to activate other devices.
    pulse_trigger_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Starts the damage sequence.
        Begin<public>():void = external {}

        # Stops the damage sequence.
        End<public>():void = external {}

        # Resumes the damage sequence from the last position where it was stopped.
        ResumeSequence<public>():void = external {}

        # Sets the damage to be applied to those hit by an active wave. Clamped between `0 <= GetDamage <= 100000`.
        # Wave visuals will change to reflect whether the wave causes damage or not.
        SetDamage<public>(Damage:float):void = external {}

        # Returns the damage to be applied to those hit by an active wave. Clamped between `0 <= GetDamage <= 100000`.
        GetDamage<public>()<transacts>:float = external {}

        # Sets the total number of waves this sequence will complete before ending its sequence. 
        # `LoopCount = 0` indicates the sequence should continue indefinitely.
        SetLoopCount<public>(LoopCount:int):void = external {}

        # Returns the total number of waves this sequence will complete before ending its sequence.
        # `0` indicates the sequence will continue indefinitely.
        GetLoopCount<public>()<transacts>:int = external {}

        # Sets the speed (in meters per second) at which the waves generated by this sequencer will travel.
        SetWaveSpeed<public>(Speed:float):void = external {}

        # Returns the speed (in meters per second) at which the waves generated by this sequencer will travel.
        GetWaveSpeed<public>()<transacts>:float = external {}

    # Base class for devices that spawn a prop object.
    prop_spawner_base_device<public> := class<abstract><epic_internal>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Spawns the prop associated with this device.
        SpawnObject<public>():void = external {}

        # Destroys all props spawned from this device.
        DestroyAllSpawnedObjects<public>():void = external {}

    # Allows customization of the Prop-o-Matic weapon functions and how the game reacts to players using it.
    prop_o_matic_manager_device<public> := class<concrete><final>(creative_device_base):

    # Base class for various powerup devices offering common events like `ItemPickedUpEvent`.
    powerup_device<public> := class<abstract><epic_internal>(creative_device_base):
        # Signaled when the powerup is picked up by an `agent`.
        # Sends the `agent` that picked up the powerup.
        ItemPickedUpEvent<public>:listenable(agent) = external {}

        # Spawns the powerup into the experience so users can interact with it.
        Spawn<public>():void = external {}

        # Despawns this powerup from the experience.
        Despawn<public>():void = external {}

        # Grants this powerup to `Agent`.
        Pickup<public>(Agent:agent):void = external {}

    # Used to move, damage, and give scores to players that interact with it. By default, it is activated by any
    # player touching its front face, which rotates it counterclockwise and knocks those players away from it and
    # slightly upward.
    pinball_flipper_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device is activated by an `agent`.
        # Sends the `agent` that activated this device.
        ActivatedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Causes `Agent` to activate this device.
        Activate<public>(Agent:agent):void = external {}

    # A triggered bumper that can knock players back, damage them, and award points.
    pinball_bumper_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device is activated by an `agent`.
        # Sends the `agent` that activated this device.
        ActivatedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Activates this device.
        Activate<public>():void = external {}

    # Specialized `trigger_base_device` that will fire output events based on line of sight between `agent`s and the device.
    perception_trigger_device<public> := class<concrete><final>(trigger_base_device):
        # Signaled when an `agent` has direct line of sight to this device.
        # Sends the `agent` that has seen this device.
        AgentLooksAtDeviceEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` has lost direct line of sight to this device.
        # Sends the `agent` that has lost sight of this device.
        AgentLooksAwayFromDeviceEvent<public>:listenable(agent) = external {}

        # Signaled when this device has direct line of sight to an `agent`.
        # Sends the `agent` seen by this device.
        DeviceSeesAgentEvent<public>:listenable(agent) = external {}

        # Signaled when this device loses direct line of sight to an `agent`.
        # Sends the `agent` this device has lost sight of.
        DeviceLosesSightOfAgentEvent<public>:listenable(agent) = external {}

    # Provides a collection of destructible devices that you can select from to use as objectives in your game.
    objective_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device has been destroyed by an `agent`.
        # Sends the `agent` that destroyed this device.
        DestroyedEvent<public>:listenable(agent) = external {}

        # Shows this device in the world.
        Show<public>():void = external {}

        # Hides this device from the world.
        Hide<public>():void = external {}

        # Activates an objective pulse at `Agent`'s location pointing toward this device.
        ActivateObjectivePulse<public>(Agent:agent):void = external {}

        # Deactivates the objective pulse at `Agent`'s location.
        DeactivateObjectivePulse<public>(Agent:agent):void = external {}

        # Destroys the objective item. This is done regardless of the visibility or health of the item.
        Destroy<public>(Agent:agent):void = external {}

    # Used to temporarily modify the speed of `agent`s and vehicles.
    movement_modulator_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device is activated by an `agent`.
        # Sends the `agent` that activated this device.
        ActivationEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Activates this device's movement effect on `Agent`.
        Activate<public>(Agent:agent):void = external {}

    # Used to take players to different islands and to link experiences together.
    matchmaking_portal_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to create custom points of interest and markers on the minimap and overview map.
    map_indicator_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Activates an objective pulse at `Agent`'s location pointing toward this device.
        ActivateObjectivePulse<public>(Agent:agent):void = external {}

        # Deactivates the objective pulse at `Agent`'s location.
        DeactivateObjectivePulse<public>(Agent:agent):void = external {}

    # Used to customize the state and accessibility of doors. `lock_device` only works with assets that have
    # a door attached.
    lock_device<public> := class<concrete><final>(creative_device_base):
        # Locks the door. `Agent` is the instigator of the action.
        Lock<public>(Agent:agent):void = external {}

        # Unlocks the door. `Agent` is the instigator of the action.
        Unlock<public>(Agent:agent):void = external {}

        # Toggles between `Lock` and `Unlock`. `Agent` is the instigator of the action.
        ToggleLocked<public>(Agent:agent):void = external {}

        # Opens the door. `Agent` is the instigator of the action.
        Open<public>(Agent:agent):void = external {}

        # Closes the door. `Agent` is the instigator of the action.
        Close<public>(Agent:agent):void = external {}

        # Toggles between `Open` and `Close`. `Agent` is the instigator of the action.
        ToggleOpened<public>(Agent:agent):void = external {}

    # Used to configuration and spawn items that players can pick up and use.
    item_spawner_device<public> := class<concrete><final>(base_item_spawner_device):
        # Cycles device to next configured item.
        CycleToNextItem<public>():void = external {}

        # Spawns the current item.
        SpawnItem<public>():void = external {}

        # Sets device *Respawn Item on Timer* option (see `SetTimeBetweenSpawns`)
        SetEnableRespawnTimer<public>(Respawn:logic):void = external {}

        # Returns device *Respawn Item on Timer* option (see `SetTimeBetweenSpawns`)
        GetEnableRespawnTimer<public>()<transacts>:logic = external {}

        # Sets the *Time Between Spawns* (in seconds) after an item is collected before the next is spawned, if this device has *Respawn Item on Timer* enabled (see `SetEnableRespawnTimer`)
        SetTimeBetweenSpawns<public>(Time:float):void = external {}

        # Returns the *Time Between Spawns* (in seconds) after an item is collected before the next is spawned, if this device has *Respawn Item on Timer* enabled (see `SetEnableRespawnTimer`)
        GetTimeBetweenSpawns<public>()<transacts>:float = external {}

    # Used to grant items to `agent`s. Items can either be dropped at the `agent`'s location or added directly to 
    # their inventory.
    item_granter_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an item is granted to an `agent`.
        # Sends the `agent` that was granted the item.
        ItemGrantedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Clears saved data for `Agent`, preventing them from receiving items while offline. This only works when 
        # *Grant While Offline* is set to *Yes*.
        ClearSaveData<public>(Agent:agent):void = external {}

        # Cycles to the next item. If *Grant on Cycle* is set `Agent` will be granted the item.
        CycleToNextItem<public>(Agent:agent):void = external {}

        # Cycles to the previous item. If *Grant on Cycle* is set `Agent` will be granted the item.
        CycleToPreviousItem<public>(Agent:agent):void = external {}

        # Cycles to a random item. If *Grant on Cycle* is set `Agent` will be granted the item.
        CycleToRandomItem<public>(Agent:agent):void = external {}

        # Grants an item to `Agent`.
        GrantItem<public>(Agent:agent):void = external {}

        # Restocks this device back to its starting inventory count.
        RestockItems<public>():void = external {}

        # Sets the next item to be granted.
        #  * `Index` should be between `0` and the available item count - 1.
        #  * Calling `SetNextItem` with an invalid index will do nothing.
        SetNextItem<public>(Index:int):void = external {}

    # Used to show custom HUD messages to one or more `agent`s.
    hud_message_device<public> := class<concrete><final>(creative_device_base):
        # Shows the currently set HUD *Message* on `Agent`s screen. Will replace any previously active message.
        # Use this when the device is setup to target specific `agent`s.
        Show<public>(Agent:agent):void = external {}

        # Shows the currently set *Message* HUD message on screen. Will replace any previously active message.
        Show<public>():void = external {}

        # Hides the HUD message.
        Hide<public>():void = external {}

        # Sets the time (in seconds) the HUD message will be displayed. `0.0` will display the HUD message persistently.
        SetDisplayTime<public>(Time:float):void = external {}

        # Returns the time (in seconds) for which the HUD message will be displayed. `0.0` means the message is
        # displayed persistently.
        GetDisplayTime<public>()<transacts>:float = external {}

        # Sets the *Message* to be displayed when the HUD message is activated. `Text` is clamped to 150 characters.
        SetText<public>(Text:message):void = external {}

    # Used to create a holographic screen that displays a clock or other curated images.
    holoscreen_device<public> := class<concrete><final>(creative_device_base):

    # Used to let `agent`s slide on any surface with accompanying visual and audio effects.
    grind_powerup_device<public> := class<concrete><final>(powerup_device):

    # Used to provide fuel sources for vehicles. Can also be used to deal considerable damage to `agent`s and the
    # environment when destroyed.
    fuel_pump_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the fuel pump is emptied.
        # Sends the `agent` that emptied the fuel pump.
        EmptyEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets fuel stock to *Fuel Capacity* value.
        Reset<public>():void = external {}

        # Grants fuel to `Agent`.
        Empty<public>(Agent:agent):void = external {}

    # Hazard which deals damage in a radius around it when destroyed or triggered.
    explosive_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device explodes.
        # Sends the `agent` that caused the explosion.
        ExplodedEvent<public>:listenable(agent) = external {}

        # Shows this device in the world.
        Show<public>():void = external {}

        # Hides this device from the world.
        Hide<public>():void = external {}

        # Resets this device.
        Reset<public>():void = external {}

        # Triggers this device to explode. Passes `Agent` as the instigator of the explosion.
        Explode<public>(Agent:agent):void = external {}

    # Used to customize high level properties of the game mode.
    experience_settings_device<public> := class<concrete><final>(creative_device_base):

    # Used to spawn items when an `agent` or specified target is eliminated.
    elimination_manager_device<public> := class<concrete><final>(base_item_spawner_device):
        # Signaled when a qualifying elimination occurs.
        # Sends the eliminated `agent`.
        EliminatedEvent<public>:listenable(agent) = external {}

        # Signaled when a qualifying elimination occurs.
        # Sends the eliminator `agent`. If the eliminator is a non-agent
        # then `false` is returned.
        EliminationEvent<public>:listenable(?agent) = external {}

    # Used to amplify an `agent`'s damage temporarily. This applies to any weapon the `agent` is using at
    # the time of the powerup.
    damage_amplifier_powerup_device<public> := class<concrete><final>(powerup_device):

    # Used to create a specialized button which can only be activated when `agent`s are carrying specific items.
    conditional_button_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device is activated.
        # Sends the `agent` that activated this device.
        ActivatedEvent<public>:listenable(agent) = external {}

        # Signaled when this device fails to activate because `agent` didn't have the required items.
        # Sends the `agent` that attempted to activate the device.
        NotEnoughItemsEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Diables this device.
        Disable<public>():void = external {}

        # Resets this device to its original settings.
        Reset<public>():void = external {}

        # Activates this device. `Agent` is used as the instigator of the action.
        Activate<public>(Agent:agent):void = external {}

        # Toggles the conditional button state. `Agent` is used as the instigator of the action.
        Toggle<public>(Agent:agent):void = external {}

        # Sets the text that appears when `agent`s approach the device. `Text` is limited to `150` characters.
        SetInteractionText<public>(Text:message):void = external {}

        # Sets the time (in seconds) that an interaction with this device should take to complete.
        SetInteractionTime<public>(Time:float):void = external {}

        # Returns the time (in seconds) that an interaction with this device will take to complete.
        GetInteractionTime<public>()<transacts>:float = external {}

        # Sets the quantity of a specific key item type that needs to be collected in order to activate the switch.
        # `KeyItemIndex` ranges from `0` to number of key item types - 1.
        SetItemCountRequired<public>(KeyItemIndex:int, Count:int):void = external {}

        # Returns the total quantity of a specific key item type that needs to be collected in order to activate the switch.
        GetItemCountRequired<public>(KeyItemIndex:int)<transacts>:int = external {}

        # Returns the remaining quantity of a specific key item type that needs to be collected in order to activate the switch.
        GetRemainingItemCountRequired<public>(KeyItemIndex:int)<transacts>:int = external {}

        # Sets the score to be awarded for a key item. `KeyItemIndex` ranges from `0` to number of key item types - 1.
        SetItemScore<public>(KeyItemIndex:int, Score:int):void = external {}

        # Returns the score to be awarded for a key item.
        GetItemScore<public>(KeyItemIndex:int)<transacts>:int = external {}

    # Used to create a tile that changes colors when `agent`s interact with it.
    color_changing_tiles_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device changes color.
        # Sends the `agent` that interacted with this device.
        ActivatedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Shows this device in the world.
        Show<public>():void = external {}

        # Hides this device from the world.
        Hide<public>():void = external {}

        # Resets this device to its initial settings.
        Reset<public>():void = external {}

        # Sets the color of the tile to `Agent`'s team color.
        SetTeam<public>(Agent:agent):void = external {}

    # Used together with `class_selector_device` to create class based gameplay. Defines custom class attributes and inventory loadouts.
    class_designer_device<public> := class<concrete><final>(creative_device_base):

    # Used together with `class_designer_device` to control how/when created classes can be accessed by `agent`s.
    class_and_team_selector_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` changes class.
        # Sends the `agent` whose class changed.
        ClassSwitchedEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` changes teams.
        # Sends the `agent` whose team changed.
        TeamSwitchedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Changes the `Agent`'s class.
        ChangeClass<public>(Agent:agent):void = external {}

        # Changes the `Agent`'s team.
        ChangeTeam<public>(Agent:agent):void = external {}

        # Changes the `Agent`'s team and class.
        ChangeTeamAndClass<public>(Agent:agent):void = external {}

        # Changes the selecting team.
        ChangeSelectorTeam<public>(Agent:agent):void = external {}

    # Spawns and tracks a single item as a game objective (e.g. flag).
    capture_item_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when spawned item is captured.
        # Sends the `agent` that captured the item.
        ItemCapturedEvent<public>:listenable(agent) = external {}

        # Signaled when spawned item is picked up.
        # Sends the `agent` that picked up the item.
        ItemPickedUpEvent<public>:listenable(agent) = external {}

        # Signaled when spawned item is dropped.
        # Sends the `agent` that dropped the item.
        ItemDroppedEvent<public>:listenable(agent) = external {}

        # Signaled when spawned item is returned.
        # Sends the `agent` that returned the item.
        ItemReturnedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to create a zone that can trigger effects once players enter it. Can be set up to be capturable by a team,
    # to provide a score while held, or to require a specific item as a drop-off.
    capture_area_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` enters this device area.
        # Sends the `agent` that entered this device area.
        AgentEntersEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` exits this device area.
        # Sends the `agent` that exited this device area.
        AgentExitsEvent<public>:listenable(agent) = external {}

        # Signaled when the first `agent` enters this device area.
        # Sends the `agent` that entered this device area.
        FirstAgentEntersEvent<public>:listenable(agent) = external {}

        # Signaled when the last `agent` exits this device area.
        # Sends the `agent` that exited this device area.
        LastAgentExitsEvent<public>:listenable(agent) = external {}

        # Signaled when this device is contested.
        # Sends the `agent` that is contesting this device.
        AreaIsContestedEvent<public>:listenable(agent) = external {}

        # Signaled when this device is scored.
        # Sends the `agent` that scored this device.
        AreaIsScoredEvent<public>:listenable(agent) = external {}

        # Signaled when this device control change starts.
        # Sends the `agent` that is triggering this device control change.
        ControlChangeStartsEvent<public>:listenable(agent) = external {}

        # Signaled when this device control changes.
        # Sends the `agent` that triggered this device control change.
        ControlChangeEvent<public>:listenable(agent) = external {}

        # Signaled when an item is consumed by this device.
        # Sends the `agent` that provided the item to this device.
        ItemIsConsumedEvent<public>:listenable(agent) = external {}

        # Signaled when an item is delivered to this device.
        # Sends the `agent` that delivered the item to this device.
        ItemIsDeliveredEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Toggles between `Enable` and `Disable`.
        ToggleEnabled<public>():void = external {}

        # Allows this device to be captured.
        AllowCapture<public>():void = external {}

        # Disallows this device from being captured.
        DisallowCapture<public>():void = external {}

        # Toggles between `AllowCapture` and `DisallowCapture`.
        ToggleCaptureAllowed<public>():void = external {}

        # Resets control of this device for all teams.
        Reset<public>():void = external {}

        # Gives control of this device to the captureing `agent`'s team.
        GiveControl<public>(Agent:agent):void = external {}

        # Clears control of this device for all teams.
        Neutralize<public>():void = external {}

        # Activates the objective pulse for this device.
        ActivateObjectivePulse<public>():void = external {}

        # Deactivates the objective pulse for this device.
        DeactivateObjectivePulse<public>():void = external {}

        # Sets the *Capture Height* (in meters) of the capture area.
        SetHeight<public>(Height:float):void = external {}

        # Returns the *Capture Height* (in meters) of the capture area.
        GetHeight<public>()<varies>:float = external {}

        # Sets the *Capture Radius* (in meters) of the capture area.
        SetRadius<public>(Radius:float):void = external {}

        # Returns the *Capture Radius* (in meters) of the capture area.
        GetRadius<public>()<varies>:float = external {}

    # Used to create a button which can trigger other devices when an agent interacts with it.
    button_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` successfully interacts with the button for `GetInteractionTime` seconds.
        # Sends the `agent` that interacted with the button.
        InteractedWithEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Sets the text that displays when an `agent` is close to this button and looks at it. `Text` is limited to
        # `64` characters.
        SetInteractionText<public>(Text:message):void = external {}

        # Sets the duration of the interaction required to activate this device (in seconds).
        SetInteractionTime<public>(Time:float):void = external {}

        # Returns the duration of the interaction required to activate this device (in seconds).
        GetInteractionTime<public>()<transacts>:float = external {}

        # Sets the maximum amount of times this button can be interacted with before it will be disabled.
        #  * `MaxCount` must be between `0` and `10`.
        #  * `0` indicates no limit on trigger count.
        SetMaxTriggerCount<public>(MaxCount:int):void = external {}

        # Returns the maximum amount of times this button can be interacted with before it will be disabled.
        #  * `GetTriggerMaxCount` will be between `0` and `10`.
        #  * `0` indicates no limit on trigger count.
        GetMaxTriggerCount<public>()<transacts>:int = external {}

        # Returns the number of times that this button can still be interacted with before it will be 
        # disabled. Will return `0` if `GetMaxTriggerCount` is unlimited.
        GetTriggerCountRemaining<public>()<transacts>:int = external {}

    # Used to display custom text messages on a billboard.
    billboard_device<public> := class<concrete><final>(creative_device_base):
        # Shows the billboard text.
        ShowText<public>():void = external {}

        # Hides the billboard text.
        HideText<public>():void = external {}

        # Updates the device display to show the current *Text*.
        UpdateDisplay<public>():void = external {}

        # Sets the visibility of the device border mesh. This also determines whether the device collision is enabled.
        SetShowBorder<public>(Show:logic):void = external {}

        # Returns `true` if the device border is enabled.
        GetShowBorder<public>()<transacts>:logic = external {}

        # Sets the device *Text*.
        SetText<public>(Text:message):void = external {}

        # Sets the *Text Size* of the device *Text*. Clamped to range [8, 24].
        SetTextSize<public>(Size:int):void = external {}

        # Returns the *Text Size* of the device *Text*.
        GetTextSize<public>()<transacts>:int = external {}

    # Used to show an in world visual effect and/or a HUD marker at the desired location.
    beacon_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # A simplified storm device that provides a way to create a single-phase storm and control its basic behaviors.
    # To control multiple phases of the storm see `advanced_storm_controller_device`.
    basic_storm_controller_device<public> := class<concrete><final>(storm_controller_device):

    # Base class for devices that spawn items.
    base_item_spawner_device<public> := class<abstract><epic_internal>(creative_device_base):
        # Signaled when an `agent` picks up the spawned item.
        # Sends the `agent` that picked up the item.
        ItemPickedUpEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to spawn various types of balls. Can be used to control HUD elements related to the spawned balls.
    ball_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Shows the floating HUD Icons to players, if these have been configured by the device.
        ShowHUD<public>():void = external {}

        # Hides the floating HUD Icons from players, if these have been configured by the device.
        HideHUD<public>():void = external {}

    # Evaluates attributes for `agent` when signaled from other devices. Acts as branching logic, checking whether the `agent` associated
    # with the signal passes all of the tests setup in this device, then sends a signal on either `PassEvent` or `FailEvent`.
    attribute_evaluator_device<public> := class<concrete><final>(trigger_base_device):
        # Signaled when the `agent` from `EvaluateAgent` passes the requirements specified by this device.
        # Sends the `agent` originally passed to this device in `EvaluateAgent`.
        PassEvent<public>:listenable(agent) = external {}

        # Signaled when the `agent` from `EvaluateAgent` fails the requirements specified by this device.
        # Sends the `agent` originally passed to this device in `EvaluateAgent`.
        FailEvent<public>:listenable(agent) = external {}

        # Tests whether the specified agent satisfies the required conditions specified on the device (e.g. eliminations/score),
        # and fires either the `PassEvent` or `FailEvent` accordingly.
        EvaluateAgent<public>(Agent:agent):void = external {}

    # Used to boost `agent`s, vehicles, and other objects upwards into the air.
    air_vent_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Activates this device.
        Activate<public>():void = external {}

    # Used to control a Battle Royale-style storm with up to 50 phases.
    # 
    # Like `basic_storm_controller_device`s, you can use this storm to keep players inside a playable area, but unlike
    # the `basic_storm_controller_device`, this device generates multiple storm phases. When used in conjunction with
    # `advanced_storm_beacon_device`s, you can customize each phase of the storm by applying one or more beacons and
    # setting customization options for the specific phase you assign to that beacon.
    advanced_storm_controller_device<public> := class<concrete><final>(storm_controller_device):

    # Used in conjunction with `advanced_storm_controller_device` to customize individual storm phases.
    advanced_storm_beacon_device<public> := class<concrete><final>(creative_device_base):

    # Spawns a lightweight vehicle made for defying gravity with its rocket boosting, jumping, and aerial maneuverability capabilities.
    vehicle_spawner_octane_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to spawn an `agent` on an island. Use multiple `player_spawner_device`s to spawn multiple `agent`s.
    player_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` is spawned from this device.
        # Sends the `agent` that spawned.
        SpawnedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to relay `agent` statistics to other devices and `agent`s. Can transmit statistics such as elimination count,
    # eliminated count, or scores when certain conditions are met. Can also project a hologram of the `agent` and display text
    # that can be altered in various positions and curvatures.
    player_reference_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device is activated.
        # Sends the `agent` stored in the device.
        ActivatedEvent<public>:listenable(agent) = external {}

        # Signaled when a stat tracked by this device is updated.
        # Sends the `agent` stored in the device.
        TrackedStatChangedEvent<public>:listenable(agent) = external {}

        # Signaled when the `agent` tracked by this device is updated.
        # Sends the new `agent` stored in the device.
        AgentUpdatedEvent<public>:listenable(agent) = external {}

        # Signaled when the `agent` tracked by this fails to be updated.
        # Sends the `agent` that attempted to be stored in this device.
        AgentUpdateFailsEvent<public>:listenable(agent) = external {}

        # Signaled when the `agent` tracked by this device is replaced.
        # Sends the new `agent` stored in the device.
        AgentReplacedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Ends the round/game.
        Activate<public>():void = external {}

        # Registers `Agent` as the `agent` being tracked by this device.
        Register<public>(Agent:agent):void = external {}

        # Clears the state of this device.
        Clear<public>():void = external {}

    # Used to select, spawn, and configure a skeletal mesh to play a specific animation.
    animated_mesh_device<public> := class<concrete><final>(creative_device_base):
        # Starts or resumes playback of the animation.
        Play<public>():void = external {}

        # Pauses playback of the animation.
        Pause<public>():void = external {}

        # Starts or resumes reverse playback of the animation.
        PlayReverse<public>():void = external {}

    # Used to trigger level sequences that allow coordination of cinematic animation, transformation, and audio tracks.
    cinematic_sequence_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the sequence is stopped.
        StoppedEvent<public>:listenable(tuple()) = external {}

        # Plays the sequence. This will only work when the device is set to *Everyone*
        Play<public>():void = external {}

        # Plays the sequence. An instigating 'Agent' is required when the device is set 
        # to anything except *Everyone*.
        Play<public>(Agent:agent):void = external {}

        # Stops the sequence.
        Stop<public>():void = external {}

        # Stops the sequence. An instigating 'Agent' is required when the device is set 
        # to anything except *Everyone*.
        Stop<public>(Agent:agent):void = external {}

        # Pauses the sequence.
        Pause<public>():void = external {}

        # Pauses the sequence. An instigating 'Agent' is required when the device is set 
        # to anything except *Everyone*.
        Pause<public>(Agent:agent):void = external {}

        # Toggles between `Play` and `Stop`.
        TogglePause<public>():void = external {}

        # Toggles between `Play` and `Stop`. An instigating 'Agent' is required when the device is set 
        # to anything except *Everyone*.
        TogglePause<public>(Agent:agent):void = external {}

    # Used to allow players to select their *Class* from a *Class Selector UI*.
    class_selector_ui_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` selects a class.
        # Sends the `agent` that selected a class.
        ClassSelectedEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` closes the UI.
        # Sends the `agent` that closed the UI.
        UIClosedEvent<public>:listenable(agent) = external {}

        # Signaled when the UI is opened.
        # Sends the `agent` that is responsible for opening the UI.
        UIOpenedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Show the *Class Selector UI* to `Agent`.
        Show<public>(Agent:agent):void = external {}

    # Used to place a campfire in the world that an `agent` can use to heal themselves.
    campfire_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` enters the area of effect for this device.
        # Sends the entering `agent`.
        AgentEntersEffectAreaEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` exits the area of effect for this device.
        # Sends the exiting `agent`.
        AgentExitsEffectAreaEvent<public>:listenable(agent) = external {}

        # Signaled when this device generates a pulse.
        CampfirePulseEvent<public>:listenable(tuple()) = external {}

        # Signaled when an `agent` is affected by a pulse generated by this device.
        # Sends the affected `agent`.
        AgentPulsedEvent<public>:listenable(agent) = external {}

        # Signaled when this device is lit by an `agent`.
        # Sends the lighting `agent`.
        LitEvent<public>:listenable(agent) = external {}

        # Signaled when this device is extinguished by an `agent`.
        # Sends the extinguishing `agent`.
        ExtinguishedEvent<public>:listenable(agent) = external {}

        # Signaled when this device is enabled.
        EnabledEvent<public>:listenable(tuple()) = external {}

        # Signaled when this device is disabled.
        DisabledEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Adds wood to this device.
        AddWood<public>():void = external {}

        # Lights this device.
        Light<public>(Agent:agent):void = external {}

        # Extinguishes this device.
        Extinguish<public>(Agent:agent):void = external {}

    # Spawns a crowd to cheer you on.
    crowd_volume_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to set up islands so players will earn Battle Pass XP when they interact with your island. Accolades
    # are achievements or accomplishments that players can complete to earn XP.
    accolades_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when testing the accolade to make sure it is awarded as expected. Only signals within
        # unpublished island environments.
        # Sends the `agent` receiving the achievement.
        TestAwardEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Awards the XP to `agent`.
        Award<public>(Agent:agent):void = external {}

    # Used to spawn guards that can patrol and attack other `agent`s.
    guard_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when a guard is spawned.
        # Sends the `agent` guard who was spawned.
        SpawnedEvent<public>:listenable(agent) = external {}

        # Enables this device. Guards will start to spawn.
        Enable<public>():void = external {}

        # Disables this device. Guards will despawn if *Despawn Guards When Disabled* is set.
        Disable<public>():void = external {}

        # Resets the spawn count allowing spawning of a new batch of guards.
        Reset<public>():void = external {}

        # Tries to spawn a guard. If *Auto Hire When Spawned* is set to *Triggering Player* the guard will be
        # hired by `Instigator`.
        Spawn<public>(Instigator:agent):void = external {}

        # Despawns guards. `Instigator` will be considered as the eliminator of those guards.
        Despawn<public>(Instigator:agent):void = external {}

        # Hires guards to `Instigator`'s team.
        Hire<public>(Instigator:agent):void = external {}

        # Dismisses all hired guards.
        DismissAllHiredGuards<public>():void = external {}

        # Dismisses all hired guards that were recruited by `Instigator`.
        DismissAgentHiredGuards<public>(Instigator:agent):void = external {}

        # Forces guard to attack `Target`, bypassing perception checks.
        ForceAttackTarget<public>(Target:agent):void = external {}

        # Allows guards to be hired.
        SetGuardsHireable<public>():void = external {}

        # Prevents guards from being hired.
        SetGuardsNotHireable<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows a helicopter to be configured and spawned.
    vehicle_spawner_helicopter_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to cause `agent`s to drop or lose items from their inventory. For example, if an `agent` is *Down But Not Out*,
    # they could drop items from their inventory, and other `agent`s could then pick up those items.
    item_remover_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Remove items from `Agent`s inventory. The items that are removed can be configured using *Affected Items*.
        Remove<public>(Agent:agent):void = external {}

    # Specialized `vehicle_spawner_device` that allows an anti-vehicle turret to be configured and spawned.
    vehicle_spawner_heavy_turret_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a UFO to be configured and spawned.
    vehicle_spawner_ufo_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to create HUD text boxes that give players information, and allows responses to be customized to player choices.
    popup_dialog_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when *Button <Index>* on this device is pushed by an `agent`.
        # Sends the `agent` that pushed the button.
        # Sends the `int` index of the clicked the button.
        RespondingButtonEvent<public>:listenable(tuple(agent, int)) = external {}

        # Signaled when this device is shown to an `agent`.
        # Sends the `agent` looking at the popup.
        ShownEvent<public>:listenable(agent) = external {}

        # Signaled when this device is dismissed by an `agent`.
        # Sends the `agent` who dismissed the popup.
        DismissedEvent<public>:listenable(agent) = external {}

        # Signaled when this device times out while an `agent` is looking at it.
        # Sends the `agent` who was looking at the popup.
        TimeOutEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Shows the popup to `Agent`.
        Show<public>(Agent:agent):void = external {}

        # Shows the popup to all `agent`s in the experience.
        Show<public>():void = external {}

        # Hides the popup from `Agent`.
        Hide<public>(Agent:agent):void = external {}

        # Hides the popup from all `agent`s in the experience.
        Hide<public>():void = external {}

        # Sets the number of buttons this popup has.
        #  Button Count is not updated on active Popups.
        SetButtonCount<public>(Count:int):void = external {}

        # Returns the *Button Text* for this popup at a specified index.
        GetButtonText<public>(Index:int)<transacts>:[]char = external {}

        # Sets the *Button Text* for a button at a specific index on this popup.
        #  * `Text` should be no more than `8` characters.
        #  * If `Text` is empty the button will show *OK* instead.
        #  * Button 1 uses `Index` 0.
        SetButtonText<public>(Text:message, Index:int):void = external {}

        # Sets the *Description* text for this popup. `Text` should be no more than `350` characters.
        SetDescriptionText<public>(Text:message):void = external {}

        # Returns the *Description* text for this popup.
        GetDescriptionText<public>()<transacts>:[]char = external {}

        # Sets the *Title* text for this popup. `Text` should be no more than `32` characters.
        SetTitleText<public>(Text:message):void = external {}

        # Returns the *Title* text for this popup.
        GetTitleText<public>()<transacts>:[]char = external {}

    # Specialized `vehicle_spawner_device` that allows a siege cannon to be configured and spawned.
    vehicle_spawner_siege_cannon_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to configure a single interactive mannequin, that can visualize characters, clothing, and perform emotes.
    character_device<public> := class<concrete>(creative_device_base):
        # Signaled when an `agent` interacts with this device.
        # Sends the `agent` that interacted with this device.
        InteractedWithEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Shows this device.
        Show<public>():void = external {}

        # Hides this device.
        Hide<public>():void = external {}

        # Plays an emote on the character created by this device.
        PlayEmote<public>():void = external {}

    # Used to set an `agent`'s spawn point when activated. This can also clear the `agent`'s inventory.
    player_checkpoint_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device is first activated by any `agent`.
        # Sends the `agent` that activated this device.
        FirstActivationEvent<public>:listenable(agent) = external {}

        # Signaled each time a new `agent` activates this device.
        # Sends the `agent` that activated this device.
        FirstActivationPerAgentEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Registers this checkpoint for `Agent`. This sets the respawn point and can clear `Agent`'s inventory
        # depending on this device's settings. Multiple `agent`s can be registered to this device at one time.
        Register<public>(Agent:agent):void = external {}

    # Physics tree that can be chopped down, and damage players, vehicles, creatures, and structures.
    physics_tree_device<public> := class<concrete><final>(physics_object_base_device):
        # Signaled when a tree is spawned.
        TreeSpawnedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the log created by a tree is destroyed.
        LogDestroyedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the stump created by a tree is destroyed.
        StumpDestroyedEvent<public>:listenable(tuple()) = external {}

        # Signaled when a tree has taken enough damage to be knocked down.
        TreeKnockedDownEvent<public>:listenable(tuple()) = external {}

        # Releases the log from the tree, if there is one.
        ReleaseLog<public>():void = external {}

        # Destroys the current log.
        DestroyLog<public>():void = external {}

        # Destroys the current stump.
        DestroyStump<public>():void = external {}

    # Base class for various physics-based gameplay elements (e.g. boulders/trees).
    physics_object_base_device<public> := class<abstract><epic_internal>(prop_spawner_base_device):

    # Physics boulder that can be dislodged and damage `agent`s, vehicles, creatures, and structures.
    physics_boulder_device<public> := class<concrete><final>(physics_object_base_device):
        # Signaled when the balanced boulder is spawned on the base.
        BalancedBoulderSpawnedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the balanced boulder is destroyed.
        BalancedBoulderDestroyedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the base of the boulder is destroyed.
        BaseDestroyedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the rolling boulder is destroyed.
        RollingBoulderDestroyedEvent<public>:listenable(tuple()) = external {}

        # Destroys the boulder's base.
        DestroyBase<public>():void = external {}

        # Releases the boulder sitting on the base, if there is one.
        ReleaseRollingBoulder<public>():void = external {}

        # Destroys the current rolling boulder.
        DestroyRollingBoulder<public>():void = external {}

    # Used to mark an `agent`'s position on the minimap and configure the information shown for marked `agent`s.
    # 
    # Example configuration options:
    #  * Health and shield bars for marked players.
    #  * Distance to a marked player.
    # 
    # Example marker appearance options:
    #  * Customized text label displayed on marked players.
    #  * Alternative minimap icon and icon color.
    player_marker_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the first item type monitored on marked agents has changed.
        # Sends the marked `agent`.
        FirstItemValueChangedEvent<public>:listenable(agent) = external {}

        # Signaled when the second item type monitored on marked agents has changed.
        # Sends the marked `agent`.
        SecondItemValueChangedEvent<public>:listenable(agent) = external {}

        # Signaled when a marked `agent` meets the quantity condition for the first monitored item type
        # (e.g. Fewer Than, Equal To, More Than X).
        # Sends the marked `agent`.
        FirstItemValueReachedEvent<public>:listenable(agent) = external {}

        # Signaled when a marked `agent` meets the quantity condition for the second monitored item type
        # (e.g. Fewer Than, Equal To, More Than X).
        # Sends the marked `agent`.
        SecondItemValueReachedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Attaches a marker to `Agent`.
        Attach<public>(Agent:agent):void = external {}

        # Detaches a marker from `Agent`.
        Detach<public>(Agent:agent):void = external {}

        # Detaches markers from all marked `agent`s.
        DetachFromAll<public>():void = external {}

    # Used to move around a building or prop, and customize responses to various collision event types.
    prop_mover_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device is enabled.
        EnabledEvent<public>:listenable(tuple()) = external {}

        # Signaled when this device is disabled.
        DisabledEvent<public>:listenable(tuple()) = external {}

        # Signaled when the prop movement begins.
        BeganEvent<public>:listenable(tuple()) = external {}

        # Signaled when the prop movement ends.
        EndedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the prop reaches its destination.
        FinishedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the prop changes its direction.
        MovementModeChangedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the prop hits an `agent`.
        # Sends the `agent` hit by the prop.
        AgentHitEvent<public>:listenable(agent) = external {}

        # Signaled when the prop hits a creature, animal, or NPC.
        AIHitEvent<public>:listenable(tuple()) = external {}

        # Signaled when the prop hits another prop.
        PropHitEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Moves the prop to its original position.
        Reset<public>():void = external {}

        # Begins the prop moving.
        Begin<public>():void = external {}

        # Ends the prop moving.
        End<public>():void = external {}

        # Moves the prop forward based on this device's default configuration, ignoring the prop's previous movement.
        Advance<public>():void = external {}

        # Reverses the prop's moving direction.
        Reverse<public>():void = external {}

        # Sets the total distance (in meters) that the prop will move.
        SetTargetDistance<public>(InDistance:float):void = external {}

        # Returns the total distance (in meters) that the prop will move.
        GetTargetDistance<public>()<transacts>:float = external {}

        # Sets the speed (in meters per second) at which the prop will move to its destination.
        SetTargetSpeed<public>(Speed:float):void = external {}

        # Returns the speed (in meters per second) at which the prop mover will move the prop to its destination.
        GetTargetSpeed<public>()<transacts>:float = external {}

    # Used to trigger in game events based on real world time.
    real_time_clock_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the optional second *Duration* time has been reached.
        DurationElapsedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the target time is reached.
        TimeReachedEvent<public>:listenable(tuple()) = external {}

        # Signaled when this device is enabled after the target time has been reached.
        EnablingAfterTimeReachedEvent<public>:listenable(tuple()) = external {}

        # Signaled when this device is enabled before the target time has been reached.
        EnablingBeforeTimeReachedEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows a Whiplash sports car to be configured and spawned.
    vehicle_spawner_sports_car_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Base class for various specialized vehicle spawners which allow specific vehicle types to be spawned and 
    # configured with specialized options.
    vehicle_spawner_device<public> := class<abstract><epic_internal>(creative_device_base):
        # Signaled when an `agent` enters the vehicle.
        # Sends the `agent` that entered the vehicle.
        AgentEntersVehicleEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` exits the vehicle.
        # Sends the `agent` that exited the vehicle.
        AgentExitsVehicleEvent<public>:listenable(agent) = external {}

        # Signaled when a vehicle is spawned or respawned by this device.
        VehicleSpawnedEvent<public>:listenable(tuple()) = external {}

        # Signaled when a vehicle is destroyed.
        VehicleDestroyedEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Sets `Agent` as the vehicle's driver.
        AssignDriver<public>(Agent:agent):void = external {}

        # Destroys the spawned vehicle if it exists.
        DestroyVehicle<public>():void = external {}

        # Spawns a new vehicle. The previous vehicle will be destroyed before a new vehicle spawns.
        RespawnVehicle<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows a taxi to be configured and spawned.
    vehicle_spawner_taxi_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a surfboard to be configured and spawned.
    vehicle_spawner_surfboard_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a shopping cart to be configured and spawned.
    vehicle_spawner_shopping_cart_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a Quadcrasher to be configured and spawned.
    vehicle_spawner_quadcrasher_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a Prevalent sedan to be configured and spawned.
    vehicle_spawner_sedan_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a Mudflap semi truck to be configured and spawned.
    vehicle_spawner_big_rig_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a Driftboard to be configured and spawned.
    vehicle_spawner_driftboard_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a cannon to be configured and spawned.
    vehicle_spawner_cannon_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a boat to be configured and spawned.
    vehicle_spawner_boat_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a Stormwing biplane to be configured and spawned.
    vehicle_spawner_biplane_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a pickup truck to be configured and spawned.
    vehicle_spawner_pickup_truck_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a Baller vehicle to be configured and spawned.
    vehicle_spawner_baller_device<public> := class<concrete><final>(vehicle_spawner_device):
        # Signaled when the vehicle runs out of energy.
        OutOfEnergyEvent<public>:listenable(tuple()) = external {}

        # Refills the vehicle's energy.
        RefillEnergy<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows an ATK (all terrain kart) to be configured and spawned.
    vehicle_spawner_atk_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Specialized `vehicle_spawner_device` that allows a tank to be configured and spawned.
    vehicle_spawner_tank_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to create a zone where players are put into a skydive state. Can customize the amount of force used to
    # push the player, and how fast players are launched into the air. The direction of the push is in relation to
    # the device, so you can rotate and overlap several devices, then use variable speeds to create pneumatic tubes
    # that propel players in different directions. You can even create unique traversal (traveling) options, where
    # players can use these zones to reach places on your island they couldn't reach any other way.
    skydive_volume_device<public> := class<concrete><final>(effect_volume_device):
        # Signaled when an `agent` enters the volume.
        # Sends the `agent` that entered the volume.
        AgentEntersEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` exits the volume.
        # Sends the `agent` that exited the volume.
        AgentExitsEvent<public>:listenable(agent) = external {}

        # Signaled when the zone changes from empty to occupied.
        # Sends the `agent` that entered the volume.
        ZoneOccupiedEvent<public>:listenable(agent) = external {}

        # Signaled when the zone changes from occupied to empty.
        # Sends the `agent` that last left the volume.
        ZoneEmptiedEvent<public>:listenable(agent) = external {}

        # Enables volume locking which prevents users from leaving the volume once they've entered.
        EnableVolumeLocking<public>():void = external {}

        # Disables volume locking which prevents users from leaving the volume once they've entered.
        DisableVolumeLocking<public>():void = external {}

    # Used to specify a zone where custom gameplay effects can be applied (e.g. gravity, no build, no weapons).
    mutator_zone_device<public> := class<concrete><final>(effect_volume_device):
        # Signaled when an `agent` in this zone begins emoting. This will not signal if the `agent` is on the
        # *Safe Team* or if *Affects Players* is disabled.
        # Sends the `agent` that started emoting.
        AgentBeginsEmotingEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` in this zone ends emoting. This will not signal if the `agent` is on the
        # *Safe Team* or if *Affects Players* is disabled.
        # Sends the `agent` that stopped emoting.
        AgentEndsEmotingEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` enters this zone.
        # Sends the `agent` entering this zone.
        AgentEntersEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` exits this zone.
        # Sends the `agent` exiting this zone.
        AgentExitsEvent<public>:listenable(agent) = external {}

        # Updates *Selected Class* to `Agent`'s class.
        UpdateSelectedClass<public>(Agent:agent):void = external {}

        # Updates *Selected Team* to `Agent`'s team.
        UpdateSelectedTeam<public>(Agent:agent):void = external {}

    # Used to specify an area which allows (or prevents) various objects, terrain, or buildings from being set on fire.
    fire_volume_device<public> := class<concrete><final>(effect_volume_device):
        # Extinguishes objects inside this device area.
        Extinguish<public>():void = external {}

        # Ignites objects inside this device area.
        Ignite<public>():void = external {}

    # Base class for types of volumes with special gameplay properties.
    effect_volume_device<public> := class<abstract><epic_internal>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to specify an area volume which can damage `agent`s, vehicles, and creatures.
    damage_volume_device<public> := class<concrete><final>(effect_volume_device):
        # Signaled when an `agent` enters the volume.
        # Sends the `agent` entering the volume.
        AgentEntersEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` exits the volume.
        # Sends the `agent` exiting the volume.
        AgentExitsEvent<public>:listenable(agent) = external {}

        # Updates *Selected Class* to `Agent`'s class.
        UpdateSelectedClass<public>(Agent:agent):void = external {}

        # Updates *Selected Team* to `Agent`'s team.
        UpdateSelectedTeam<public>(Agent:agent):void = external {}

        # Sets the damage to be applied each tick within the volume. `Damage` is clamped between `1` and `500`.
        SetDamage<public>(Damage:int):void = external {}

        # Returns the damage to be applied each tick within the volume.
        GetDamage<public>()<transacts>:int = external {}

    # Creates an impenetrable zone that can block `agent` movement and weapon fire.
    barrier_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to spawn various wildlife that players can herd, hunt, or tame.
    wildlife_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device spawns wildlife.
        # Sends the `agent` wildlife that was spawned.
        SpawnedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets the count on the *Total Spawn Count* option.
        Reset<public>():void = external {}

        # Spawns wildlife from this device.
        Spawn<public>():void = external {}

        # Despawns wildlife. `Agent` is marked as the one who eliminated the wildlife.
        Despawn<public>(Agent:agent):void = external {}

        # Destroys this device, marking `Agent` as the destroyer of the device.
        DestroySpawner<public>(Agent:agent):void = external {}

        # Tames wildlife, making them AI partners of `Agent`.
        Tame<public>(Agent:agent):void = external {}

        # Untames any tamed wildlife that belong to `Agent`.
        Untame<public>(Agent:agent):void = external {}

        # Untames all wildlife.
        UntameAll<public>():void = external {}

        # Teleports `Agent` to the nearest wildlife, then `Agent` mounts that wildlife.
        Ride<public>(Agent:agent):void = external {}

        # Dismounts `Agent` from wildlife.
        Dismount<public>(Agent:agent):void = external {}

        # Dismounts all `agent`s from wildlife.
        DismountAll<public>():void = external {}

        # Restores energy to wildlife belonging to `Agent` by *Energy Restore Amount*.
        RestoreEnergy<public>(Agent:agent):void = external {}

        # Restores energy to wildlife by *Energy Restore Amount*.
        RestoreEnergyForAll<public>():void = external {}

        # Consumes energy from wildlife belonging to `Agent` by *Energy Consume Amount*.
        ConsumeEnergy<public>(Agent:agent):void = external {}

        # Consumes energy from wildlife by *Energy Consume Amount*.
        ConsumeEnergyForAll<public>():void = external {}

    # Used to allow agents to turn other linked devices on/off or other custom state changes.
    switch_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the switch is turned on by the specified `agent`.
        # Sends the `agent` that turned on the device.
        TurnedOnEvent<public>:listenable(agent) = external {}

        # Signaled when the switch is turned off by the specified `agent`.
        # Sends the `agent` that turned off the device.
        TurnedOffEvent<public>:listenable(agent) = external {}

        # Signaled if the switch is on when the state is checked.
        IfOnWhenCheckedEvent<public>:listenable(tuple()) = external {}

        # Signaled if the switch is off when the state is checked.
        IfOffWhenCheckedEvent<public>:listenable(tuple()) = external {}

        # Signaled when the switch state is saved.
        StateSaveEvent<public>:listenable(tuple()) = external {}

        # Signaled when the switch state changes.
        StateChangesEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Turns on this device with `Agent` acting as the instigator of the action.
        TurnOn<public>(Agent:agent):void = external {}

        # Turns off the device with `Agent` acting as the instigator of the action.
        TurnOff<public>(Agent:agent):void = external {}

        # Toggles between `TurnOn` and `TurnOff` with `Agent` acting as the instigator of the action.
        ToggleState<public>(Agent:agent):void = external {}

        # Loads the device state with `Agent` acting as the instigator of the action.
        LoadState<public>(Agent:agent):void = external {}

        # Saves the device state with `Agent` acting as the instigator of the action.
        SaveState<public>(Agent:agent):void = external {}

        # Checks the device state with `Agent` acting as the instigator of the action.
        CheckState<public>(Agent:agent):void = external {}

        # Clears persistence data for `Agent`.
        ClearPersistenceData<public>(Agent:agent):void = external {}

        # Clears persistence data for all `agent`s.
        ClearAllPersistenceData<public>():void = external {}

        # Returns the current state of this switch: true (on) or false (off). Use this overload  of `GetCurrentState`
        # when this device has *Store State Per Player* set to *Yes*.
        GetCurrentState<public>(Agent:agent)<transacts><decides>:void = external {}

        # Returns the current state of this switch: true (on) or false (off). Use this overload  of `GetCurrentState`
        # when this device has *Store State Per Player* set to *No*.
        GetCurrentState<public>()<transacts><decides>:void = external {}

        # Query whether this device has a single global on/off state, or has a personalized on/off state for
        # each individual agent.
        IsStatePerAgent<public>()<transacts><decides>:void = external {}

        # Sets the *Interaction Time* required to activate this device (in seconds).
        SetInteractionTime<public>(Time:float):void = external {}

        # Returns the *Interaction Time* required to activate this device (in seconds).
        GetInteractionTime<public>()<transacts>:float = external {}

        # Sets the *Turn On Text* to be displayed to a user when the switch is currently off, and offers an interaction to
        # switch it on. Clamped to 150 characters.
        SetTurnOnInteractionText<public>(Text:message):void = external {}

        # Sets the *Turn Off Text* to be displayed to a user when the switch is currently on, and offers an interaction to
        # switch it off. Clamped to 150 characters.
        SetTurnOffInteractionText<public>(Text:message):void = external {}

    # Used to place a crash pad that can bounce players and protect them from fall damage.
    crash_pad_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` is launched by this device.
        # Sends the launched `agent`.
        LaunchedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to add fishing mechanics to experiences, such as:
    #  * Fishing competitions between players.
    #  * Collecting fish as a resource.
    #  * Fishing minigames with their own rewards.
    fishing_zone_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` catches a fish.
        # Sends the `agent` that caught the fish.
        CaughtEvent<public>:listenable(agent) = external {}

        # Signaled when all items have been caught and removed.
        # Sends the `agent` that caught the last fish.
        EmptyEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets the number of available uses for this device back to *Uses Allowed*.
        Reset<public>():void = external {}

        # Returns all caught and removed items to the inventory. This only works when *Pool Type* is set to *Device Inventory*.
        Restock<public>():void = external {}

    # Used with the `race_checkpoint_device` to create more advanced racing modes.
    race_manager_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the race begins.
        # Sends the `agent` that started the race.
        RaceBeganEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` finishes the race.
        # Sends the `agent` that finished the race.
        RaceCompletedEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` completes their first lap.
        # Sends the `agent` that finished the lap.
        FirstLapCompletedEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` completes a lap.
        # Sends the `agent` that finished the lap.
        LapCompletedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Begins the race.
        Begin<public>():void = external {}

        # Ends the race.
        End<public>():void = external {}

    # Used in tandem with `race_manager_device` to define the route players must traverse.
    race_checkpoint_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this checkpoint becomes the next checkpoint that `agent`s need to pass for the first time.
        # Sends the first `agent` who is now targeting this checkpoint.
        CheckpointBecomesCurrentForTheFirstTimeEvent<public>:listenable(agent) = external {}

        # Signaled when this checkpoint becomes the current checkpoint for `agent`.
        # Sends the `agent` who is now targeting this checkpoint.
        CheckpointBecomesCurrentEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` passes this checkpoint.
        # Sends the `agent` that passed this checkpoint.
        CheckpointCompletedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Sets this checkpoint as the current checkpoint for `Agent`. This only functions if `Agent` has not already
        # passed this checkpoint.
        SetAsCurrentCheckpoint<public>(Agent:agent):void = external {}

    # Used to regenerate an `agent`'s health and/or shields.
    health_powerup_device<public> := class<concrete><final>(powerup_device):

    # Used to configure rules that can end the current round or game.
    end_game_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Ends the round/game. Uses `Agent`'s team to determine if the round/game ends when *Activating Team* is enabled.
        Activate<public>(Agent:agent):void = external {}

    # Used to show or hide parts of the HUD for players or teams. Use this with other devices such as the
    # `hud_message_device`, `map_indicator_device`, and `billboard_device` to control exactly how much information
    # players can see during a game, as well as how and when they see that information.
    hud_controller_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Sets the *Affected Class* option to `Agent`'s class.
        UpdateAffectedClass<public>(Agent:agent):void = external {}

        # Sets the *Affected Team* option to `Agent`'s team.
        UpdateAffectedTeam<public>(Agent:agent):void = external {}

        # Resets the *Affected Class* option to its starting value.
        ResetAffectedClass<public>():void = external {}

        # Resets the *Affected Team* option to its starting value.
        ResetAffectedTeam<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows an armored battle bus to be configured and spawned.
    vehicle_spawner_armored_battle_bus_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to create patrolling behavior for guards spawned with the `guard_spawner_device`.
    ai_patrol_path_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when a guard reaches this device.
        NodeReachedEvent<public>:listenable(tuple()) = external {}

        # Signaled when a guard cannot reach the next `ai_patrol_path_device`.
        NextNodeUnreachableEvent<public>:listenable(tuple()) = external {}

        # Signaled when a guard starts moving on the patrol path.
        PatrolPathStartedEvent<public>:listenable(tuple()) = external {}

        # Signaled when a guard stops moving on the patrol path.
        PatrolPathStoppedEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Commands current patrollers to follow the *Next Patrol Path Group* instead of the default *Patrol Path Group*.
        GoToNextPatrolGroup<public>():void = external {}

    # Allows players to change their outfit in game!
    changing_booth_device<public> := class<concrete><final>(creative_device_base):

    # Used to trigger a custom response to a *Primary* or *Secondary* signal, sent by a *Signal Remote* item.
    signal_remote_manager_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when a player has triggered the *Primary* signal using a *Signal Remote* item.
        # Sends the `agent` that triggered the signal.
        PrimarySignalEvent<public>:listenable(agent) = external {}

        # Signaled when a player has triggered the *Secondary* signal using a *Signal Remote* item.
        # Sends the `agent` that triggered the signal.
        SecondarySignalEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to configure and play audio from the device location or from registered `agent`s.
    audio_player_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device. Allows this device to be triggered from other linked 
        # devices (i.e. triggers) and allow calls to `Play` to succeed.
        Enable<public>():void = external {}

        # Disables this device. No longer allows this device to be triggered from other
        # linked devices (i.e. triggers) and will stop any currently playing audio.
        Disable<public>():void = external {}

        # Starts playing audio from this device for `Agent`. This can only be used when the device is set
        # to be *Heard by Instigator*.
        Play<public>(Agent:agent):void = external {}

        # Starts playing audio from this device.
        Play<public>():void = external {}

        # Stops any audio playing from this device for `Agent`. This can only be used when the device is set
        # to be *Heard by Instigator*.
        Stop<public>(Agent:agent):void = external {}

        # Stops any audio playing from this device.
        Stop<public>():void = external {}

        # Adds `Agent` as a target to play audio from when activated.
        Register<public>(Agent:agent):void = external {}

        # Removes `Agent` as a target to play audio from when activated.
        Unregister<public>(Agent:agent):void = external {}

        # Removes all previously registered `agent`s as valid targets to play audio from when activated.
        UnregisterAll<public>():void = external {}

    # Used to spawn one or more waves of creatures of customizable types at selected time intervals.
    creature_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Destroys this device.
        DestroySpawner<public>():void = external {}

        # Eliminates all creatures spawned by this device.
        EliminateCreatures<public>():void = external {}

    # Used to spawn a creature at a specified location.
    creature_placer_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the creature is eliminated.
        #  * Sends the `agent` that eliminated the creature.
        #  * Sends `false` if the creature was eliminated by
        #    something other than an `agent` (e.g. a vehicle).
        EliminatedEvent<public>:listenable(?agent) = external {}

        # Spawns the creature.
        Spawn<public>():void = external {}

        # Despawns the creature.
        Despawn<public>():void = external {}

    # Used to customize one creature type at a time. Place multiple `creature_manager_device`s for each type of
    # creature on your island.
    creature_manager_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when a creature of the selected *Creature Type* is eliminated.
        # Sends the `agent` that eliminated the creature.
        MatchingCreatureTypeEliminatedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to spawn fireflies that can be collected by `agent`s.
    firefly_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when a firefly is collected.
        # Sends the `agent` collected the firefly.
        OnFirefliesCollected<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Spawns new fireflies. The previous fireflies will be destroyed before a new fireflies spawn.
        Respawn<public>():void = external {}

        # Resets respawn count.
        ResetRespawnCount<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows a dirtbike to be configured and spawned.
    vehicle_spawner_dirtbike_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to customize (or prevent) the 'down but not out' player state between 'healthy' and 'removed from game'.
    down_but_not_out_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` is set to the `down but not out` player state.
        # Sends the `agent` that was downed.
        AgentDownedEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` in the `down but not out` player state is picked up.
        # Sends the `agent` that was picked up.
        AgentPickedUpEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` in the `down but not out` player state is dropped.
        # Sends the `agent` that was dropped.
        AgentDroppedEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` in the `down but not out` player state is thrown.
        # Sends the `agent` that was thrown.
        AgentThrownEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` in the `down but not out` player state is revived.
        # Sends the `agent` that was revived.
        AgentRevivedEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` is the aggressor of a shake down.
        # Sends the `agent` that is the aggressor.
        ShakeDownEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` is the victim of a shake down.
        # Sends the `agent` that is the victim.
        ShakenDownEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Sets the `Agent` to the `down but not out` player state.
        Down<public>(Agent:agent):void = external {}

        # Sets the `Agent` to the `healthy` player state if they are in the `down but not out` player state.
        Revive<public>(Agent:agent):void = external {}

    # Allows pickup items to be placed in the world..
    item_placer_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to project a hologram of a character performing dance emotes.
    dance_mannequin_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Activates the hologram using *Default Preset* options.
        ActivateDefaultPreset<public>():void = external {}

        # Activates the hologram using *Preset 2* options.
        ActivatePreset2<public>():void = external {}

        # Activates the hologram using *Preset 3* options.
        ActivatePreset3<public>():void = external {}

        # Activates the hologram using `Agent`'s skin and emotes.
        ActivateSkinAndEmoteCapture<public>(Agent:agent):void = external {}

        # Deactivates the hologram.
        DeactivateSkinAndEmoteCapture<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows a Nitro Drifter sedan to be configured and spawned.
    vehicle_spawner_nitro_drifter_sedan_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Used to manipulate the properties of one or more props in a specified area (e.g. Visibility/Destructibility).
    prop_manipulator_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when props affected by this device are damaged.
        # Sends the `agent` that damaged the prop.
        DamagedEvent<public>:listenable(agent) = external {}

        # Signaled when props affected by this device are destroyed.
        # Sends the `agent` that destroyed the prop.
        DestroyedEvent<public>:listenable(agent) = external {}

        # Signaled when prop resource nodes affected by this device are harvested.
        # Sends the `agent` that harvested resources from the prop.
        HarvestingEvent<public>:listenable(agent) = external {}

        # Signaled when prop resource nodes affected by this device are completely depleted of energy.
        # Sends the `agent` that depleted the prop's energy.
        ResourceDepletionEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Shows all props affected by this device.
        ShowProps<public>():void = external {}

        # Hides all props affected by this device.
        HideProps<public>():void = external {}

        # Empties the resources of all props affected by this device.
        ExhaustResources<public>():void = external {}

        # Restocks the resources of all props affected by this device.
        RestockResources<public>():void = external {}

        # Restores health of all props affected by this device.
        RestoreHealth<public>():void = external {}

        # Sets the *Override Resource* option to *Yes*.
        SetResourceOverridesActive<public>():void = external {}

        # Sets the *Override Resource* option to *No*.
        DisableResourceNodeOverrides<public>():void = external {}

    # Used to track and react to how many players are in a particular area, and optionally display that information in game.
    player_counter_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the player count matches *Target Player Count*. The frequency of evaluation
        # against *Target Player Count* can be controlled through the device settings.
        CountSucceedsEvent<public>:listenable(tuple()) = external {}

        # Signaled when the player count does not match *Target Player Count*. The frequency of evaluation
        # against *Target Player Count* can be controlled through the device settings.
        CountFailsEvent<public>:listenable(tuple()) = external {}

        # Signaled when a valid player enters the zone and is counted. The frequency of evaluation
        # against the *Target Player Count* can be controlled through the device settings.
        # Sends the `agent` that is now being counted.
        CountedEvent<public>:listenable(agent) = external {}

        # Signaled when a player is no longer counted by this device, such as when they leave the zone, leave the game,
        # or are assigned to a different `team` or class.
        # Sends the `agent` that is no longer being counted.
        RemovedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets *Target Player Count* to the default value defined in the device settings. If *Target Player Count*
        # was previously incremented or decremented, this reset immediately triggers a new comparison.
        Reset<public>():void = external {}

        # Increments *Target Player Count* by `1`. Immediately triggers a new comparison.
        IncrementTargetCount<public>():void = external {}

        # Decrements *Target Player Count* by `1`. Immediately triggers a new comparison.
        DecrementTargetCount<public>():void = external {}

        # Triggers an evaluation of the current count vs *Target Player Count*, signaling `CountSuccceedsEvent`
        # or `CountFailsEvent` based on the evaluation result.
        CompareToTarget<public>():void = external {}

        # Triggers `CountedEvent` for all `agent`s currently being counted.
        TransmitForAllCounted<public>():void = external {}

        # Show this device in the world as an info panel showing Current + Required player counts.
        ShowInfoPanel<public>():void = external {}

        # Hide this device info panel from the world.
        HideInfoPanel<public>():void = external {}

        # Returns whether this device is represented in the world as an info panel showing Current + Required player counts.
        IsShowingInfoPanel<public>()<transacts><decides>:void = external {}

        # Sets the number of players required for this counter to succeed. Immediately triggers a new comparison.
        SetTargetCount<public>(Count:int):void = external {}

        # Returns the number of players required for this counter to succeed.
        GetTargetCount<public>()<transacts>:int = external {}

    # Used to display curated videos onto in-game screens or player HUDs.
    video_player_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when this device becomes the controlling streaming device for the `agent`.
        StreamStartedEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Enables collision checks on this device.
        EnableCollision<public>():void = external {}

        # Disables collision checks on this device.
        DisableCollision<public>():void = external {}

        # Transitions to fullscreen for `Agent`.
        EnterFullScreen<public>(Agent:agent):void = external {}

        # Transitions to fullscreen for `Agent`.
        ExitFullScreen<public>(Agent:agent):void = external {}

        # Hides the picture-in-picture video from `Agent`.
        HidePIP<public>(Agent:agent):void = external {}

        # Transitions the picture-in-picture video to the default size for `Agent`.
        MakePIPDefaultSize<public>(Agent:agent):void = external {}

        # Transitions the picture-in-picture video to full screen for `Agent`.
        MakePIPFullScreen<public>(Agent:agent):void = external {}

        # Turns off all streaming devices of this type on the island.
        EndForAll<public>():void = external {}

        # Restart the stream from the beginning.
        Restart<public>():void = external {}

        # Seeks to the *Triggered Seek Time*. Caution: The stream will pause while the video buffers when seeking.
        Seek<public>():void = external {}

        # Stops the currently playing stream and starts the custom stream with the audio only playing
        # from this device. *Stream Priority* will not work until control is released.
        TakeControl<public>():void = external {}

        # If any streaming device has forced control of the stream, this will release it and play the highest
        # priority stream in line.
        ReleaseControl<public>():void = external {}

    # Used to create a light which can have its color and brightness manipulated in response to in-game events.
    customizable_light_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets the light to its initial state.
        Reset<public>():void = external {}

        # Turns on the light.
        TurnOn<public>():void = external {}

        # Turns off the light.
        TurnOff<public>():void = external {}

        # Toggles between `TurnOn` and `TurnOff`.
        Toggle<public>():void = external {}

        # Dims the light by *Dimming Amount*.
        DimLight<public>():void = external {}

        # Brightens the light by *Dimming Amount*.
        UndimLight<public>():void = external {}

    # Used to spawn and configure an aerial supply drop that can provide players with customized weapons/supplies.
    supply_drop_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the balloon on the supply crate is popped.
        # Sends the `?agent` that popped the balloon. If no `agent` popped the balloon
        # returns `false`.
        BalloonPoppedEvent<public>:listenable(?agent) = external {}

        # Signaled when the supply crate is opened.
        # Sends the `agent` that opened the crate.
        OpenedEvent<public>:listenable(agent) = external {}

        # Signaled when the supply crate lands for the first time.
        LandingEvent<public>:listenable(tuple()) = external {}

        # Spawns a supply drop provided one hasn't already spawned. *Owning Team* is set to `Agent`'s team.
        Spawn<public>(Agent:agent):void = external {}

        # Spawns a supply drop provided one hasn't already spawned.
        Spawn<public>():void = external {}

        # Destroys the balloon and causes the supply crate to freefall.
        DestroyBalloon<public>():void = external {}

        # Opens the supply crate, ignoring the locked or unlocked state. `Agent` acts as the instigator of the open action.
        Open<public>(Agent:agent):void = external {}

        # Locks the supply crate so `agent`s cannot open it.
        Lock<public>():void = external {}

        # Unlocks the supply crate so `agent`s can open it.
        Unlock<public>():void = external {}

    # Controls how the sky looks, as well as giving you options for changing the sun, clouds, stars or other 
    # objects in the sky above your island. You can control the sun and moon, and add other atmospheric
    # elements like stars, fog and clouds. You can change the color of your light source, and blend different
    # colors for your island's sky to create the perfect atmosphere for your game.
    skydome_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Specialized `vehicle_spawner_device` that allows a sportbike to be configured and spawned.
    vehicle_spawner_sportbike_device<public> := class<concrete><final>(vehicle_spawner_device):

    # Generates an AI bot that spawns in a location and usually attacks players when they come in range.
    sentry_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the sentry is alerted to an `agent`.
        # Sends the `agent` who alerted the sentry.
        AlertedEvent<public>:listenable(agent) = external {}

        # Signaled when the sentry exists the alert state.
        ExitsAlertEvent<public>:listenable(tuple()) = external {}

        # Signaled when the sentry enters the alert state.
        EntersAlertCooldownEvent<public>:listenable(tuple()) = external {}

        # Signaled when a sentry attacks an `agent`.
        # Sends the `agent` who is being attacked.
        AttackingEvent<public>:listenable(agent) = external {}

        # Signaled when a sentry is eliminated.
        # Sends the `agent` that eliminated the sentry. If the sentry was eliminated by a non-agent
        # then `false` is returned.
        EliminatedEvent<public>:listenable(?agent) = external {}

        # Signaled when the sentry eliminates a creature.
        EliminatingACreatureEvent<public>:listenable(tuple()) = external {}

        # Signaled when a sentry eliminates an `agent`.
        # Sends the `agent` who was eliminated by the sentry.
        EliminatingAgentEvent<public>:listenable(agent) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Spawns the sentry.
        Spawn<public>():void = external {}

        # Destroys the current sentry.
        DestroySentry<public>():void = external {}

        # Sets the sentry to the same team `Agent` is on.
        JoinTeam<public>(Agent:agent):void = external {}

        # Resets the sentry to the original team desiganted in the device options.
        ResetTeam<public>():void = external {}

        # Puts the sentry into the pacify state, preventing from entering the alert (attacking) state.
        Pacify<public>():void = external {}

        # Puts the sentry into the alert state.
        EnableAlert<public>():void = external {}

        # Sets the sentry to target `Agent`. The sentry will not target agents on the same team as the sentry.
        Target<public>(Agent:agent):void = external {}

        # Resets the alert state.
        ResetAlertCooldown<public>():void = external {}

    # Used to create and customize your own visual effects. This is more flexible than the `vfx_spawner_device`,
    # which gives you a selection of pre-made visual effects to choose from but limits how much you can customize
    # or change those effects.
    vfx_creator_device<public> := class<concrete><final>(creative_device_base):
        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Toggles between `Enable` and `Disable`.
        ToggleEnabled<public>():void = external {}

        # Starts playing the effect.
        Begin<public>():void = external {}

        # Starts the effect at `Agent`'s location. This option is only valid if *Stick to Player* is enabled.
        Begin<public>(Agent:agent):void = external {}

        # Starts the effect at every `agent`'s location. This option is only valid if *Stick to Player* is enabled.
        BeginForAll<public>():void = external {}

        # Ends playing the effect.
        End<public>():void = external {}

        # Ends the effect at `Agent`'s location. This option is only valid if *Stick to Player* is enabled.
        End<public>(Agent:agent):void = external {}

        # Ends the effect at every `agent`'s locations. This option is only valid if *Stick to Player* is enabled.
        EndForAll<public>():void = external {}

        # Toggles between `Begin` and `End`.
        Toggle<public>():void = external {}

        # Toggles between `Begin` and `End`.
        Toggle<public>(Agent:agent):void = external {}

        # Toggles between `BeginForAll` and `EndForAll`.
        ToggleForAll<public>():void = external {}

        # Pauses the effect if the effect is running. If the effect is paused, unpauses the effect. Pausing an effect
        # causes the effect to freeze in place.
        TogglePause<public>():void = external {}

        # Pauses the effect at `Agent`'s locations if it is playing, or resumes the effect if it is paused.
        # When paused the effect freezes in place.
        TogglePause<public>(Agent:agent):void = external {}

        # Pauses the effect at every `agent`'s locations if it is playing, or resumes the effect if it is paused.
        # When paused the effect freezes in place.
        TogglePauseForAll<public>():void = external {}

        # Removes the effect from `Agent` and continues playing at the device location. This option is only valid if
        # *Stick to Player* is enabled.
        Remove<public>(Agent:agent):void = external {}

        # Removes the effect for every `agent` and continues playing at the device location. This option is only valid if
        # *Stick to Player* is enabled.
        RemoveFromAll<public>():void = external {}

        # Spawns the effect at `Agent`'s location. This option is only valid if *Stick to Player* is enabled.
        SpawnAt<public>(Agent:agent):void = external {}

    # Used to place visual effects around your island. You can use these effects to enhance the overall theme
    # and experience of your game.
    vfx_spawner_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when the effect is enabled.
        EffectEnabledEvent<public>:listenable(tuple()) = external {}

        # Signaled when the effect is disabled.
        EffectDisabledEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

    # Used to create and manipulate volumes of water where players can swim, fish, or drive boats.
    water_device<public> := class<concrete><final>(creative_device_base):
        # Signaled when an `agent` enters the water.
        # Sends `agent` that entered the water.
        AgentEntersWaterEvent<public>:listenable(agent) = external {}

        # Signaled when an `agent` exits the water.
        # Sends `agent` that exited the water.
        AgentExitsWaterEvent<public>:listenable(agent) = external {}

        # Signals when the volume is filled to the water level set in the *Default Vertical Water Percentage* option.
        VerticalFillingCompletedEvent<public>:listenable(tuple()) = external {}

        # Signals when the water volume is completely empty.
        VerticalEmptyingCompletedEvent<public>:listenable(tuple()) = external {}

        # Enables this device.
        Enable<public>():void = external {}

        # Disables this device.
        Disable<public>():void = external {}

        # Resets the water level in the volume to the value set in the *Default Vertical Water Percentage* option.
        Reset<public>():void = external {}

        # Starts vertically emptying the water in the volume.
        BeginVerticalEmptying<public>():void = external {}

        # Starts vertically filling the water in the volume.
        BeginVerticalFilling<public>():void = external {}

        # Stops filling or emptying the volume.
        StopVerticalMovement<public>():void = external {}

        # Resumes either filling or emptying the volume.
        ResumeVerticalMovement<public>():void = external {}

using {/Fortnite.com/Teams}
using {/Verse.org/Simulation}
using {/Fortnite.com/Characters}
# Module import path: /Fortnite.com/Vehicles
Vehicles<public> := module:
    # Returns the `fort_vehicle` for `InCharacter`.
    # Fails if `InCharacter` is not associated with a `fort_vehicle`.
    (InCharacter:fort_character).GetVehicle<native><public>()<transacts><decides>:fort_vehicle

    # Main API implemented by Fortnite vehicles.
    fort_vehicle<native><public> := interface<unique><epic_internal>(positional, healthful, damageable):

# Module import path: /Fortnite.com/Teams
Teams<public> := module:
    # A generic set of team attitudes. Use this enum to model relationship behavior between your experience's
    # agents/teams.
    team_attitude<native><public> := enum:
        # Agents/teams are friends. In Fortnite games two `agent`s on the same `team` are `friendly`.
        Friendly
        # Agents/teams are neutral. In Fortnite games items and AI not belonging to a `friendly` or `hostile`
        # team are `neutral`.
        Neutral
        # Agents/teams are hostile. In fortnite games two `agent`s on opposing `team`s are `hostile`.
        Hostile

    # Collection used to manage `team`s and `agent`s on those teams.
    # Use `fort_playspace.GetTeamCollection()` to get the `team_collection` for the active experience.
    fort_team_collection<native><public> := interface:
        # Returns an array of all the `team`s known to this `fort_team_collection`
        GetTeams<public>()<transacts>:[]team

        # Adds `InAgent` to `InTeam`.
        # Fails if `InTeam` is not part of the `fort_team_collection`.
        AddToTeam<public>(InAgent:agent, InTeam:team)<transacts><decides>:void

        # Succeeds if `InAgent` is on `InTeam`.
        # Fails if:
        #  * `InAgent` is not on `InTeam`.
        #  * `InTeam` is not part of the `fort_team_collection`.
        IsOnTeam<public>(InAgent:agent, InTeam:team)<transacts><decides>:void

        # Returns an array of all `agent`s on `InTeam`.
        # Fails if `InTeam` is not part of the `fort_team_collection`.
        GetAgents<public>(InTeam:team)<transacts><decides>:[]agent

        # Get the `team` that `InAgent` is on.
        # Fails if `InAgent` is not on a team in this `fort_team_collection`.
        GetTeam<public>(InAgent:agent)<transacts><decides>:team

        # Returns the `team_attitude` between `Team1` and `Team2`.
        # Fails if:
        #  * `Team1` is not in this `fort_team_collection`.
        #  * `Team2` is not in this `fort_team_collection`.
        GetTeamAttitude<public>(Team1:team, Team2:team)<transacts><decides>:team_attitude

        # Returns the `team_attitude` between `Agent1` and `Agent2`.
        # Fails if:
        #  * `Agent1` is not on a team in this `fort_team_collection`.
        #  * `Agent2` is not on a team in this `fort_team_collection`.
        GetTeamAttitude<public>(Agent1:agent, Agent2:agent)<transacts><decides>:team_attitude

# Module import path: /Fortnite.com/Playspaces
Playspaces<public> := module:
    # A nested container that scopes objects, style, gameplay rules, visuals, etc. All objects
    # and players in an experience will belong to a fort_playspace. There is typically one `fort_playspace`
    # for an entire experience, though this may change in the future as the platform evolves.
    #  
    # To access the `fort_playspace` for a `creative_device` use `creative_device.GetPlayspace`.
    fort_playspace<native><public> := interface:
        # Get an `[]player`s in the current `fort_playspace`.
        GetPlayers<public>()<transacts>:[]player

        # Get the `fort_team_collection` for the current `fort_playspace`.
        GetTeamCollection<public>()<transacts>:fort_team_collection

        # Signaled when a `player` joins the `fort_playspace`. Returns a subscribable with a payload of the
        # `fort_character` that entered the `fort_playspace`.
        PlayerAddedEvent<public>():subscribable(player)

        # Signaled when a `player` leaves the `fort_playspace`. Returns a subscribable with a payload of the
        # `fort_character` that left the `fort_playspace`.
        PlayerRemovedEvent<public>():subscribable(player)

# Module import path: /Fortnite.com/Game
Game<public> := module:
    # Result data for `fort_character` elimination events.
    elimination_result<native><public> := struct<epic_internal>:
        # The `fort_character` eliminated from the match by `EliminatingCharacter`.
        EliminatedCharacter<native><public>:fort_character

        # `fort_character` that eliminated `EliminatedCharacter` from the match. `EliminatingCharacter` will be false
        # when `EliminatedCharacter` was eliminated through non-character actions, such as environmental damage.
        EliminatingCharacter<native><public>:?fort_character

    # Implemented by objects to allow reading position information.
    positional<native><public> := interface<epic_internal>:
        # Returns the transform of the object.
        GetTransform<public>()<transacts>:transform

    # Implemented by Fortnite objects that have health state and can be eliminated.
    healthful<native><public> := interface<epic_internal>:
        # Returns the health state of the object. This value will between 0.0 and `GetMaxHealth`
        GetHealth<public>()<transacts>:float

        # Sets the health state of the object to `Health`.
        #  * Health state will be clamped between 1.0 and `GetMaxHealth`.
        #  * Health state cannot be directly set to 0.0. To eliminate `healthful` objects use the
        #    `damageable.Damage` functions instead.
        SetHealth<public>(Health:float)<transacts>:void

        # Returns the maximum health of the object. This value will be between 1.0 and Inf.
        GetMaxHealth<public>()<transacts>:float

        # Sets the maximum health state of the object.
        #  * MaxHealth will be clamped between 1.0 and Inf.
        #  * Current health state will be scaled up or down based on the scale difference between the old and new
        #    MaxHealth state.
        SetMaxHealth<public>(MaxHealth:float)<transacts>:void

    # Implemented by Fortnite objects that have shields. A shield is a method of protection that can take incoming
    # damage while leaving the health state unchanged.
    shieldable<native><public> := interface<epic_internal>:
        # Returns the shield state of the object. This value will between 0.0 and `MaxShield`
        GetShield<public>()<transacts>:float

        # Sets the shield state of the object.
        #  * Shield state will be clamped between 0.0 and `MaxShield`.
        SetShield<public>(Shield:float)<transacts>:void

        # Returns the maximum shield state of the object. This value will be between 0.0 and Inf.
        GetMaxShield<public>()<transacts>:float

        # Sets the maximum shield state of the object.
        #  * MaxShield will be clamped between 0.0 and Inf.
        #  * Current shield state will be scaled up or down based on the scale difference between the old and new
        #    MaxShield state.
        SetMaxShield<public>(MaxShield:float)<transacts>:void

        # Signaled when the shield is damaged.
        DamagedShieldEvent<public>():listenable(damage_result)

        # Signaled when the shield is healed.
        HealedShieldEvent<public>():listenable(healing_result)

    # Implemented by Fortnite objects that can be damaged.
    damageable<native><public> := interface<epic_internal>:
        # Damage the `damageable` object anonymously by `Amount`. Setting `Amount` to less than 0 will cause no damage.
        # Use `Damage(:damage_args):void` when damage is being applied from a known instigator and source.
        Damage<public>(Amount:float):void

        # Damage the `damagable` object by `Args.Amount`. Setting `Amount` to less than 0 will cause no damage.
        Damage<public>(Args:damage_args):void

        # Signaled when damage is applied to the `damagable` object.
        DamagedEvent<public>():listenable(damage_result)

    # Implemented by Fortnite objects that can be healed.
    healable<native><public> := interface<epic_internal>:
        # Heal the `healable` object anonymously by `Amount`. Setting `Amount` to less than 0 will cause no healing.
        # Use `Heal(:healing_args):void` when healing is being applied from a known instigator and source.
        Heal<public>(Amount:float):void

        # Cause `Args.Amount` damage to the `damageable` object. Setting `Amount` to less than 0 will cause no damage.
        Heal<public>(Args:healing_args):void

        # Signaled when healing is applied to the `healable` object.
        HealedEvent<public>():listenable(healing_result)

    # Parameters for common damage functions on Fortnite objects.
    damage_args<native><public> := struct:
        # Player, agent, etc. that instigated the damage to the object.
        Instigator<native><public>:?game_action_instigator = external {}

        # Player, weapon, vehicle, etc. that damaged the object.
        Source<native><public>:?game_action_causer = external {}

        # Amount of damage to apply to the object.
        Amount<native><public>:float

    # Results for damage events on Fortnite objects.
    damage_result<native><public> := struct<epic_internal>:
        # Object that was damaged.
        Target<native><public>:damageable

        # Amount of damage applied to `Target`.
        Amount<native><public>:float

        # Player, agent, etc. that instigated the damage to `Target`. Can be false when damage is instigated by
        # code, the environment, etc.
        Instigator<native><public>:?game_action_instigator = external {}

        # Player, weapon, vehicle, etc. that damaged `Target`. Can be false when damage is caused by code, the
        # environment, etc.
        Source<native><public>:?game_action_causer = external {}

    # Parameters for common healing functions on Fortnite objects.
    healing_args<native><public> := struct:
        # Player, agents, etc. that instigated the healing of the object.
        Instigator<native><public>:?game_action_instigator = external {}

        # Player, weapon, vehicle, etc. that healed the object.
        Source<native><public>:?game_action_causer = external {}

        # Amount of healing to apply to the object.
        Amount<native><public>:float

    # Results for healing events on Fortnite objects.
    healing_result<native><public> := struct<epic_internal>:
        # Object that was healed.
        Target<native><public>:healable

        # Amount of healing applied to `Target`.
        Amount<native><public>:float

        # Player, agent, etc. that instigated healing of the `Target`. Can be false when damage is instigated by
        # code, the environment, etc.
        Instigator<native><public>:?game_action_instigator = external {}

        # Player, weapon, vehicle, etc. that healed `Target`. Can be false when damage is caused by code, the
        # environment, etc.
        Source<native><public>:?game_action_causer = external {}

    # Implemented by Fortnite objects that initiate game actions, such as damage and heal. For example, player or agents.
    # Event listeners often use `game_action_instigators` to calculate player damage scores.
    game_action_instigator<native><public> := interface<epic_internal>:

    # Implemented by Fortnite objects that can be passed through game action events, such as damage and heal.
    # For example: player, vehicle, or weapon.
    # 
    # Event Listeners often use `game_action_causer` to pass along additional information about what weapon caused the damage.
    # Systems will then use that information for completing quests or processing game specific event logic.
    game_action_causer<native><public> := interface:

# Module import path: /Fortnite.com/FortPlayerUtilities
FortPlayerUtilities<public> := module:
    # Sends `InPlayer` back to the main game lobby.
    (InPlayer:player).SendToLobby<native><public>()<transacts>:void

    # Succeeds if `InPlayer` is spectating the experience. Fails otherwise.
    (InPlayer:player).IsSpectator<native><public>()<transacts><decides>:void

    # Returns an `[]player`s currently spectating `InPlayer`.
    (InPlayer:player).GetPlayersSpectating<native><public>()<transacts>:[]player

    # Respawns the character for `InAgent` at the provided `RespawnPosition` and `RespawnRotation`.
    (InAgent:agent).Respawn<native><public>(RespawnPosition:vector3, RespawnRotation:rotation)<transacts>:void

# Module import path: /Fortnite.com/Characters
Characters<public> := module:
    # Main API implemented by Fortnite characters.
    fort_character<native><public> := interface<unique><epic_internal>(positional, healable, healthful, damageable, shieldable, game_action_instigator, game_action_causer):
        # Returns the agent associated with this `fort_character`. Use this when interacting with APIs that require an `agent` reference.
        GetAgent<public>()<transacts><decides>:agent

        # Signaled when this `fort_character` is eliminated from the match.
        EliminatedEvent<public>():listenable(elimination_result)

        # Returns the rotation defining where this `fort_character` is looking/aiming.
        GetViewRotation<public>()<transacts>:rotation

        # Signaled when this `fort_character` jumps. Returns a listenable with a payload of this `fort_character`.
        JumpedEvent<public>():listenable(fort_character)

        # Signaled when this `fort_character` changes crouch state.
        # Sends `tuple` payload:
        #  - 0: the `fort_character` that changed crouch states.
        #  - 1: `true` if the character is crouching. `false` if the character is not crouching.
        CrouchedEvent<public>():listenable(tuple(fort_character, logic))

        # Signaled when this `fort_character` changes sprint state.
        # Sends `tuple` payload:
        #  - 0: the `fort_character` that changed sprint state.
        #  - 1: `true` if the character is sprinting. `false` if the character stopped sprinting.
        SprintedEvent<public>():listenable(tuple(fort_character, logic))

        # Succeeds if this `fort_character` is in the world and has not been eliminated. Most fort_character actions will silently fail if this fails. Please test IsActive if you want to handle these failure cases rather than allow them to silently fail.
        IsActive<public>()<transacts><decides>:void

        # Succeeds if this `fort_character` is in the 'Down But Not Out' state. In this state the character is down but
        # can still be revived by teammates for a period of time.
        IsDownButNotOut<public>()<transacts><decides>:void

        # Puts this `fort_character` into stasis, preventing certain types of movement specificed by `Args`.
        PutInStasis<public>(Args:stasis_args)<transacts>:void

        # Release this `fort_character` from stasis.
        ReleaseFromStasis<public>()<transacts>:void

        # Sets this `fort_character` visibility to visible.
        Show<public>():void

        # Sets this `fort_character` visibility to invisible.
        Hide<public>():void

        # Control if this `fort_character` can be damaged.
        SetVulnerability<public>(Vulnerable:logic)<transacts>:void

        # Succeeds if this `fort_character` can be damaged. Fails if this `fort_character` cannot be damaged.
        IsVulnerable<public>()<transacts><decides>:void

    # Returns the `fort_character` for `InAgent`. Fails if `InAgent` is not a `fort_character`.
    (InAgent:agent).GetFortCharacter<native><public>()<transacts><decides>:fort_character

    # Returns a `game_action_intigator` interface for `InAgent`.
    (InAgent:agent).GetInstigator<native><public>()<transacts>:game_action_instigator

    # Returns the `agent` for `InInstigator`. Fails if `InInstigator` is not an `agent`.
    (InInstigator:game_action_instigator).GetInstigatorAgent<native><public>()<transacts><decides>:agent

    # Parameters for `fort_character.PutInStasis` function.
    stasis_args<native><public> := struct:
        # Controls if `fort_character` can still turn while in stasis.
        AllowTurning<native><public>:logic = external {}

        # Controls if `fort_character` can still fall while in stasis.
        AllowFalling<native><public>:logic = external {}

        # Controls if `fort_character` can still perform emotes while in stasis.
        AllowEmotes<native><public>:logic = external {}

UnrealEngine.digest.verse

# Copyright Epic Games, Inc. All Rights Reserved.
#################################################
# Generated Digest of Verse API
# DO NOT modify this manually!
# Generated from build: ++Fortnite+Release-24.20-CL-25058254
#################################################

Temporary<public> := module:
    using {/Verse.org/Colors}
    using {/UnrealEngine.com/Temporary/SpatialMath}
    using {/Verse.org/Simulation}
    # Module import path: /UnrealEngine.com/Temporary/UI
    UI<public> := module:
        # Verse interface to native `widget_class`.
        widget_class<native><public> := class<computes><final>:

        # Returns the `player_ui` component associated with `Player`.
        # Fails if there is no `player_ui` associated with `Player`.
        GetPlayerUI<native><public>(Player:player)<transacts><decides>:player_ui

        # The main interface for adding and removing `widget`s to a player's UI.
        player_ui<native><public> := class<final><epic_internal>:
            # Adds `Widget` to this `player_ui` using default `player_ui_slot` configuration options.
            AddWidget<native><public>(Widget:widget):void

            # Adds `Widget` to this `player_ui` using `Slot` for configuration options.
            AddWidget<native><public>(Widget:widget, Slot:player_ui_slot):void

            # Removes `Widget` from this `player_ui`.
            RemoveWidget<native><public>(Widget:widget):void

        # Base class for all UI elements drawn on the `player`'s screen.
        widget<native><public> := class<abstract><unique><epic_internal>:
            # Shows or hides the `widget` without removing itself from the containing `player_ui`.
            # See `widget_visibility` for details.
            SetVisibility<native><public>(InVisibility:widget_visibility):void

            # Returns the current `widget_visbility` state.
            GetVisibility<native><public>():widget_visibility

            # Enables or disables whether the `player` can interact with this `widget`.
            SetEnabled<native><public>(InIsEnabled:logic):void

            # `true` if this `widget` can be modified interactively by the player.
            IsEnabled<native><public>():logic

            # Returns the `widget`'s parent `widget`.
            # Fails if no parent exists, such as if this `widget` is not in the `player_ui` or is itself the root `widget`.
            GetParentWidget<native><public>()<transacts><decides>:widget

            # Returns the `widget` that added this `widget` to the `player_ui`. The root `widget` will return itself.
            # Fails if this `widget` is not in the `player_ui`.
            GetRootWidget<native><public>()<transacts><decides>:widget

        # `widget` creation configuration options.
        player_ui_slot<native><public> := struct:
            # Controls `widget` rendering order. Greater values will be draw in front of lesser values.
            ZOrder<native><public>:type {_X:int where 0 <= _X, _X <= 2147483647} = external {}

            # Controls `widget` input event consumption.
            InputMode<native><public>:ui_input_mode = external {}

        # `widget` input consumption mode.
        ui_input_mode<native><public> := enum:
            # `widget` does not consume any input.
            None
            # `widget` consumes all inputs
            All

        # Parameters for `event`s signalled by a `widget`.
        widget_message<native><public> := struct:
            # The `player` that triggered the `event`.
            Player<native><public>:player

            # The `widget` that triggered the `event`.
            Source<native><public>:widget

        # Used by `widget.SetVisibility` determine how a `widget` is shown in the user interface.
        widget_visibility<native><public> := enum:
            # The `widget` is visible and occupies layout space.
            Visible
            # The `widget` is invisible and does not occupy layout space.
            Collapsed
            # The `widget` is invisible and occupies layout space.
            Hidden

        # Used by`widget` orientation modes.
        orientation<native><public> := enum:
            # Orient `widget`s from left to right.
            Horizontal
            # Orient `widget`s from top to bottom.
            Vertical

        # `widget` horizontal alignment mode.
        horizontal_alignment<native><public> := enum:
            # Center `widget` horizontally within the slot.
            Center
            # Align `widget` to the left of the slot.
            Left
            # Align `widget` to the right of the slot.
            Right
            # `widget` fills the slot horizontally.
            Fill

        # `widget` vertical alignment mode.
        vertical_alignment<native><public> := enum:
            # Center `widget` vertically within the slot.
            Center
            # Align `widget` to the top of the slot.
            Top
            # Align `widget` to the bottom of the slot.
            Bottom
            # `widget` fills the slot vertically.
            Fill

        # The anchors of a `widget` determine its the position and sizing relative to its parent.
        # `anchor`s range from `(0.0, 0.0)` (left, top) to `(1.0, 1.0)` (right, bottom).
        anchors<native><public> := struct:
            # Holds the minimum anchors, (left, top). The valid range is between `0.0` and `1.0`.
            Minimum<native><public>:vector2 = external {}

            # Holds the maximum anchors, (right, bottom). The valid range is between `0.0` and `1.0`.
            Maximum<native><public>:vector2 = external {}

        # Specifies the gap outside each edge separating a `widget` from its neighbors.
        # Distance is measured in units where `1.0` unit is the width of a pixel at 1080p resolution.
        margin<native><public> := struct:
            # The left edge spacing.
            Left<native><public>:float = external {}

            # The top edge spacing.
            Top<native><public>:float = external {}

            # The right edge spacing.
            Right<native><public>:float = external {}

            # The bottom edge spacing.
            Bottom<native><public>:float = external {}

        # Button is a container of a single child widget slot and fires the OnClick event when the button is clicked.
        button<native><public> := class<final>(widget):
            # The child widget of the button. Used only during initialization of the widget and not modified by SetSlot.
            Slot<native><public>:button_slot

            # Sets the child widget slot.
            SetWidget<native><public>(InSlot:button_slot):void

            # Subscribable event that fires when the button is clicked.
            OnClick<public>():listenable(widget_message) = external {}

        # Slot for button widget.
        button_slot<native><public> := struct:
            # The widget assigned to this slot.
            Widget<native><public>:widget

            # Horizontal alignment of the widget inside the slot.
            HorizontalAlignment<native><public>:horizontal_alignment = external {}

            # Vertical alignment of the widget inside the slot.
            VerticalAlignment<native><public>:vertical_alignment = external {}

            # Empty distance in pixels that surrounds the widget inside the slot. Assumes 1080p resolution.
            Padding<native><public>:margin = external {}

        # Canvas is a container widget that allows for arbitrary positioning of widgets in the canvas' slots.
        canvas<native><public> := class<final>(widget):
            # The child widgets of the canvas. Used only during initialization of the widget and not modified by Add/RemoveWidget.
            Slots<native><public>:[]canvas_slot = external {}

            # Adds a new child slot to the canvas.
            AddWidget<native><public>(Slot:canvas_slot):void

            # Removes a slot containing the given widget.
            RemoveWidget<native><public>(Widget:widget):void

        # Slot for a canvas widget.
        canvas_slot<native><public> := struct:
            # The border for the margin and how the widget is resized with its parent.
            # Values are defined between 0.0 and 1.0.
            Anchors<native><public>:anchors = external {}

            # The offset that defined the size and position of the widget.
            # When the anchors are well defined, the Offsets.Left represent the distance in pixels from the Anchors Minimum.X,
            # the Offsets.Bottom represent the distance in pixel from the Anchors Maximun.Y, effectily controlling the desired
            # widget size. When the anchors are not well defined, the Offsets.Left and Offsets.Top represent the widget position
            # and Offsets.Right and Offset.Bottom represent the widget size.
            Offsets<native><public>:margin = external {}

            # When true we use the widget's desired size. The size calculated by the Offets is ignored.
            SizeToContent<native><public>:logic = external {}

            # Alignment is the pivot/origin point of the widget.
            # Starting in the upper left at (0.0,0.0), ending in the lower right at (1.0,1.0).
            Alignment<native><public>:vector2 = external {}

            # Z Order of this slot relative to other slots in this canvas panel.
            # Higher values are rendered last (and so they will appear to be on top)
            ZOrder<native><public>:type {_X:int where 0 <= _X, _X <= 2147483647} = external {}

            # The widget assigned to this slot.
            Widget<native><public>:widget

        # Make a canvas slot for fixed position widget.
        # If Size is set, then the Offsets is calculated and the SizeToContent is set to false.
        # If Size is not set, then Right and Bottom are set to zero and are not used. The widget size will be automatically calculated. The SizeToContent is set to true.
        # The widget is not anchored and will not move if the parent is resized.
        # The Anchors is set to zero.
        MakeCanvasSlot<native><public>(Widget:widget, Position:vector2, ?Size:vector2 = external {}, ?ZOrder:type {_X:int where 0 <= _X, _X <= 2147483647} = external {}, ?Alignment:vector2 = external {})<computes>:canvas_slot

        # A solid color widget.
        color_block<native><public> := class<final>(widget):
            # The color of the widget. Used only during initialization of the widget and not modified by SetColor.
            DefaultColor<native><public>:color = external {}

            # The opacity of the widget. Used only during initialization of the widget and not modified by SetOpacity.
            DefaultOpacity<native><public>:type {_X:float where 0.000000 <= _X, _X <= 1.000000} = external {}

            # The size this widget desired to be displayed in. Used only during initialization of the widget and not modified by SetDesiredSize.
            DefaultDesiredSize<native><public>:vector2 = external {}

            # Sets the widget's color.
            SetColor<native><public>(InColor:color):void

            # Gets the widget's color.
            GetColor<native><public>():color

            # Sets the widgets's opacity.
            SetOpacity<native><public>(InOpacity:type {_X:float where 0.000000 <= _X, _X <= 1.000000}):void

            # Gets the widget's opacity.
            GetOpacity<native><public>():type {_X:float where 0.000000 <= _X, _X <= 1.000000}

            # Sets the size this widget desired to be displayed in.
            SetDesiredSize<native><public>(InDesiredSize:vector2):void

            # Gets the size this widget desired to be displayed in.
            GetDesiredSize<native><public>():vector2

        # Overlay is a container consisting of widgets stacked on top of each other.
        overlay<native><public> := class<final>(widget):
            # The child widgets of the overlay. Used only during initialization of the widget and not modified by Add/RemoveWidget.
            Slots<native><public>:[]overlay_slot = external {}

            # Add a new child slot to the overlay. Slots are added at the end.
            AddWidget<native><public>(Slot:overlay_slot):void

            # Removes a slot containing the given widget
            RemoveWidget<native><public>(Widget:widget):void

        # Slot for an overlay widget
        overlay_slot<native><public> := struct:
            # The widget assigned to this slot.
            Widget<native><public>:widget

            # Horizontal alignment of the widget inside the slot.
            # This alignment is only applied after the layout space for the widget slot is created and determines the widget alignment within that space.
            HorizontalAlignment<native><public>:horizontal_alignment = external {}

            # Vertical alignment of the widget inside the slot.
            # This alignment is only applied after the layout space for the widget slot is created and determines the widget alignment within that space.
            VerticalAlignment<native><public>:vertical_alignment = external {}

            # Empty distance in pixels that surrounds the widget inside the slot. Assumes 1080p resolution.
            Padding<native><public>:margin = external {}

        # Stack box is a container of a list of widgets stacked either vertically or horizontally.
        stack_box<native><public> := class<final>(widget):
            # The child widgets of the stack box. Used only during initialization of the widget and not modified by Add/RemoveWidget.
            Slots<native><public>:[]stack_box_slot = external {}

            # The orientation of the stack box. Either stack widgets horizontal or vertical.
            Orientation<native><public>:orientation

            # Add a new child slot to the stack box. Slots are added at the end.
            AddWidget<native><public>(Slot:stack_box_slot):void

            # Removes a slot containing the given widget
            RemoveWidget<native><public>(Widget:widget):void

        # Slot for a stack_box widget
        stack_box_slot<native><public> := struct:
            # The widget assigned to this slot.
            Widget<native><public>:widget

            # Horizontal alignment of the widget inside the slot.
            # This alignment is only applied after the layout space for the widget slot is created and determines the widget alignment within that space.
            HorizontalAlignment<native><public>:horizontal_alignment = external {}

            # Vertical alignment of the widget inside the slot.
            # This alignment is only applied after the layout space for the widget slot is created and determines the widget alignment within that space.
            VerticalAlignment<native><public>:vertical_alignment = external {}

            # Empty distance in pixels that surrounds the widget inside the slot. Assumes 1080p resolution.
            Padding<native><public>:margin = external {}

            # The available space will be distributed proportionally.
            # If not set, the slot will use the desired size of the widget.
            Distribution<native><public>:?float = external {}

        # Text justification values:
        #   Left: Justify the text logically to the left.
        #   Center: Justify the text in the center.
        #   Right: Justify the text logically to the right.
        # The Left and Right value will flip when the local culture is right-to-left.
        text_justification<native><public> := enum:
            Left
            Center
            Right

        # Text overflow policy values:
        #   Clip: Overflowing text will be clipped.
        #   Ellipsis: Overflowing text will be replaced with an ellipsis.
        text_overflow_policy<native><public> := enum:
            Clip
            Ellipsis

        # Base widget for text widget.
        text_base<native><public> := class<abstract>(widget):
            # The text to display to the user. Used only during initialization of the widget and not modified by SetText.
            DefaultText<native><localizes><public>:message = external {}

            # The color of the displayed text. Used only during initialization of the widget and not modified by SetTextColor.
            DefaultTextColor<native><public>:color = external {}

            # The opacity of the displayed text. Used only during initialization of the widget and not modified by SetTextOpacity.
            DefaultTextOpacity<native><public>:type {_X:float where 0.000000 <= _X, _X <= 1.000000} = external {}

            # The justification to display to the user. Used only during initialization of the widget and not modified by SetJustification.
            DefaultJustification<native><public>:text_justification = external {}

            # The policy that determine what happens when the text is longer than its allowed length.
            #  Used only during initialization of the widget and not modified by SetOverflowPolicy.
            DefaultOverflowPolicy<native><public>:text_overflow_policy = external {}

            # Sets the text displayed in the widget.
            SetText<native><public>(InText:message):void

            # Gets the text currently in the widget.
            GetText<native><public>():[]char

            # Sets the text justification in the widget.
            SetJustification<native><public>(InJustification:text_justification):void

            # Gets the text justificattion in the widget.
            GetJustification<native><public>():text_justification

            # Sets the policy that determine what happens when the text is longer than its allowed length.
            SetOverflowPolicy<native><public>(InOverflowPolicy:text_overflow_policy):void

            # Gets the policy that determine what happens when the text is longer than its allowed length.
            GetOverflowPolicy<native><public>():text_overflow_policy

            # Sets the color of the displayed text.
            SetTextColor<native><public>(InColor:color):void

            # Gets the color of the displayed text.
            GetTextColor<native><public>():color

            # Sets the opacity of the displayed text.
            SetTextOpacity<native><public>(InOpacity:type {_X:float where 0.000000 <= _X, _X <= 1.000000}):void

            # Gets the opacity of the displayed text.
            GetTextOpacity<native><public>():type {_X:float where 0.000000 <= _X, _X <= 1.000000}

    using {/Verse.org/Native}
    # Module import path: /UnrealEngine.com/Temporary/SpatialMath
    SpatialMath<public> := module:
        @editable
        @import_as("/Script/EpicGamesTemporary.FVerseRotation")
        rotation<native><public> := struct<concrete>:

        # Makes a `rotation` from `Axis` and `AngleRadians` using a left-handed sign convention (e.g.
        # a positive rotation around +Z takes +X to +Y). If `Axis.IsAlmostZero[]`, make the identity rotation.
        MakeRotation<native><public>(Axis:vector3, AngleRadians:float)<varies>:rotation

        # Makes a `rotation` by applying `YawRightDegrees`, `PitchUpDegrees`, and `RollClockwiseDegrees`, in that order:
        #  * first a *yaw* about the Z axis with a positive angle indicating a clockwise rotation when viewed from above,
        #  * then a *pitch* about the new Y axis with a positive angle indicating 'nose up',
        #  * followed by a *roll* about the new X axis axis with a positive angle indicating a clockwise rotation when viewed along +X.
        # Note that these conventions differ from `MakeRotation` but match `ApplyYaw`, `ApplyPitch`, and `ApplyRoll`.
        MakeRotationFromYawPitchRollDegrees<native><public>(YawRightDegrees:float, PitchUpDegrees:float, RollClockwiseDegrees:float)<varies>:rotation

        # Makes the identity `rotation`.
        IdentityRotation<native><public>()<converges>:rotation

        # Returns the 'distance' between `Rotation1` and `Rotation2`. The result will be between:
        #  * `0.0`, representing equivalent rotations and
        #  * `1.0` representing rotations which are 180 degrees apart (i.e., the shortest rotation between them is 180 degrees around some axis).
        Distance<native><public>(Rotation1:rotation, Rotation2:rotation)<varies>:float

        # Makes a `rotation` by applying `PitchUpRadians` of right-handed rotation around the local +Y axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyPitch<native><public>(PitchUpRadians:float)<transacts>:rotation

        # Makes a `rotation` by applying `RollClockwiseRadians` of right-handed rotation around the local +X axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyRoll<native><public>(RollClockwiseRadians:float)<transacts>:rotation

        # Makes a `rotation` by applying `YawRightRadians` of left-handed rotation around the local +Z axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyYaw<native><public>(YawRightRadians:float)<transacts>:rotation

        # Makes a `rotation` by applying `AngleRadians` of left-handed rotation around the world +X axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyWorldRotationX<native><public>(AngleRadians:float)<transacts>:rotation

        # Makes a `rotation` by applying `AngleRadians` of left-handed rotation around the world +Y axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyWorldRotationY<native><public>(AngleRadians:float)<transacts>:rotation

        # Makes a `rotation` by applying `AngleRadians` of left-handed rotation around the world +Z axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyWorldRotationZ<native><public>(AngleRadians:float)<transacts>:rotation

        # Makes a `rotation` by applying `AngleRadians` of left-handed rotation around the local +Y axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyLocalRotationY<public>(AngleRadians:float)<transacts>:rotation = external {}

        # Makes a `rotation` by applying `AngleRadians` of left-handed rotation around the local +Z axis to `InitialRotation`.
        (InitialRotation:rotation).ApplyLocalRotationZ<public>(AngleRadians:float)<transacts>:rotation = external {}

        # Makes a `rotation` by composing `AdditionalRotation` to `InitialRotation`.
        (InitialRotation:rotation).RotateBy<native><public>(AdditionalRotation:rotation)<transacts>:rotation

        # Makes a `rotation` by composing the inverse of `RotationToRemove` from `InitialRotation`. such that InitialRotation = RotateBy(UnrotateBy(InitialRotation, RotationToRemove), RotationToRemove). This is equivalent to RotateBy(InitialRotation, InvertRotation(RotationToRemove))
        (InitialRotation:rotation).UnrotateBy<native><public>(RotationToRemove:rotation)<transacts>:rotation

        # Makes an `[]float` with three elements:
        #  * *yaw* degrees of `rotation`
        #  * *pitch* degrees of `rotation`
        #  * *roll* degrees of `rotation`
        # using the conventions of `MakeRotationFromYawPitchRollDegrees`.
        (Rotation:rotation).GetYawPitchRollDegrees<native><public>()<varies>:[]float

        # Makes a `vector3` from the axis of `rotation`.
        # If `rotation` is nearly identity, this will return the +X axis. See also `GetAngle`.
        (Rotation:rotation).GetAxis<native><public>()<varies>:vector3

        # Returns the radians of `rotation` around the axis of `rotation`. See also `GetAxis`.
        (Rotation:rotation).GetAngle<native><public>()<varies>:float

        # Makes the smallest angular `rotation` from `InitialRotation` to `FinalRotation` such that:
        # `InitialRotation.RotateBy(MakeShortestRotationBetween(InitialRotation, FinalRotation)) = FinalRotation` and
        # `MakeShortestRotationBetween(InitialRotation, FinalRotation)?.GetAngle()` is as small as possible.
        MakeShortestRotationBetween<native><public>(InitialRotation:rotation, FinalRotation:rotation)<transacts>:rotation

        # Makes the smallest angular `rotation` from `InitialVector` to `FinalVector` such that:
        # `InitialVector.RotateBy(MakeShortestRotationBetween(InitialVector, Vector)) = FinalVector` and
        # `MakeShortestRotationBetween(InitialVector, FinalVector)?.GetAngle()` is as small as possible.
        MakeShortestRotationBetween<native><public>(InitialVector:vector3, FinalVector:vector3)<transacts>:rotation

        # Used to perform spherical linear interpolation between `From` (when `Parameter = 0.0`)
        # and `To` (when `Parameter = 1.0`). Expects that `0.0 <= Parameter <= 1.0`.
        Slerp<native><public>(InitialRotation:rotation, FinalRotation:rotation, Parameter:float)<transacts><decides>:rotation

        # Makes a `vector3` by applying `Rotation` to `Vector`.
        (Rotation:rotation).RotateVector<native><public>(Vector:vector3)<transacts>:vector3

        # Makes a `vector3` by applying the inverse of `Rotation` to `Vector`.
        (Rotation:rotation).UnrotateVector<native><public>(Vector:vector3)<transacts>:vector3

        # Makes a `rotation` by inverting `Rotation` such that `ApplyRotation(Rotation, Rotation.Invert())) = IdentityRotation`.
        (Rotation:rotation).Invert<native><public>()<transacts>:rotation

        # Returns `Rotation` if it does not contain `NaN`, `Inf` or `-Inf`.
        (Rotation:rotation).IsFinite<native><public>()<computes><decides>:rotation

        # Makes a unit `vector3` pointing in the local space *forward* direction in world space coordinates.
        # This is equivalent to: `RotateVector(Rotation, vector3{X:=1.0, Y:=0.0, Z:=0.0})`.
        (Rotation:rotation).GetLocalForward<public>()<transacts>:vector3 = external {}

        # Makes a unit `vector3` pointing in the the local space *right* direction in world space coordinates.
        # This is equivalent to: `RotateVector(Rotation, vector3{X:=0.0, Y:=1.0, Z:=0.0})`.
        (Rotation:rotation).GetLocalRight<public>()<transacts>:vector3 = external {}

        # Makes a unit `vector3` pointing in the local space *up* direction in world space coordinates.
        # This is equivalent to: `RotateVector(Rotation, vector3{X:=0.0, Y:=0.0, Z:=1.0})`.
        (Rotation:rotation).GetLocalUp<public>()<transacts>:vector3 = external {}

        # Makes a `string` representation of `rotation` in axis/degrees format with a left-handed sign convention.
        # `ToString(MakeRotation(vector3{X:=1.0, Y:=0.0, Z:=0.0}, PiFloat/2.0))` produces the string:
        # `"Axis: {x=1.000000,y=0.000000,z=0.000000} Angle: 90.000000"`.
        ToString<native><public>(Rotation:rotation)<varies>:[]char

        # Returns radians from `Degrees`.
        DegreesToRadians<public>(Degrees:float)<varies>:float = external {}

        # Returns degrees from `Radians`.
        RadiansToDegrees<public>(Radians:float)<varies>:float = external {}

        # A combination of scale, rotation, and translation, applied in that order.
        transform<native><public> := struct<concrete><computes>:
            @editable
            # The scale of this `transform`.
            Scale<native><public>:vector3 = external {}

            @editable
            # The rotation of this `transform`.
            Rotation<native><public>:rotation = external {}

            @editable
            # The location of this `transform`.
            Translation<native><public>:vector3 = external {}

        # Makes a `vector3` by applying `InTransform` to `InVector`.
        TransformVector<native><public>(InTransform:transform, InVector:vector3)<varies>:vector3

        # Makes a `vector3` by applying `InTransform` to `InVector` without applying `InTransform.Scale`.
        TransformVectorNoScale<native><public>(InTransform:transform, InVector:vector3)<varies>:vector3

        # 2-dimensional vector with `float` components.
        vector2<native><public> := struct<concrete><computes>:
            @editable
            X<native><public>:float = external {}

            @editable
            Y<native><public>:float = external {}

        # Makes a `vector2` by inverting the `SurfaceNormal` component of `Direction`.
        # Fails if `not SurfaceNormal.MakeUnitVector[]`.
        ReflectVector<native><public>(Direction:vector2, SurfaceNormal:vector2)<varies><decides>:vector2

        # Returns the dot product of `V1` and `V2`.
        DotProduct<native><public>(V1:vector2, V2:vector2)<varies>:float

        # Returns the Euclidean distance between `V1` and `V2`.
        Distance<native><public>(V1:vector2, V2:vector2)<varies>:float

        # Returns the squared Euclidean distance between `V1` and `V2`.
        DistanceSquared<native><public>(V1:vector2, V2:vector2)<varies>:float

        # Makes a unit length `vector3` pointing in the same direction of `V`.
        # Fails if `V.IsAlmostZero[] or not V.IsFinite[]`.
        (V:vector2).MakeUnitVector<native><public>()<varies><decides>:vector2

        # Returns the length of `V`.
        (V:vector2).Length<public>()<varies>:float = external {}

        # Returns the squared length of `V`.
        (V:vector2).LengthSquared<public>()<varies>:float = external {}

        # Used to linearly interpolate/extrapolate between `From` (when `Parameter = 0.0`)
        # and `To` (when `Parameter = 1.0`). Expects that all arguments are finite.
        # Returns `From*(1 - Parameter) + To*Parameter`.
        Lerp<public>(From:vector2, To:vector2, Parameter:float)<varies>:vector2 = external {}

        # Makes a `string` representation of `V`.
        ToString<native><public>(V:vector2)<varies>:[]char

        # Makes a `vector2` by inverting the signs of `Operand`.
        prefix'-'<public>(Operand:vector2)<computes>:vector2 = external {}

        # Makes a `vector2` by component-wise addition of `Left` and `Right`.
        operator'+'<public>(Left:vector2, Right:vector2)<computes>:vector2 = external {}

        # Makes a `vector2` by component-wise subtraction of `Right` from `Left`.
        operator'-'<public>(Left:vector2, Right:vector2)<computes>:vector2 = external {}

        # Makes a `vector2` by component-wise multiplication of `Left` and `Right`.
        operator'*'<public>(Left:vector2, Right:float)<computes>:vector2 = external {}

        # Makes a `vector2` by multiplying the components of `Right` by `Left`.
        operator'*'<public>(Left:float, Right:vector2)<computes>:vector2 = external {}

        # Makes a `vector2` by dividing the components of `Left` by `Right`.
        operator'/'<public>(Left:vector2, Right:float)<computes>:vector2 = external {}

        # Makes a `vector2` by converting the components of `V` to `float`s.
        ToVector2<public>(V:vector2i)<transacts>:vector2 = external {}

        # Returns `V` if all components are finite.
        # Fails if any of the components are not finite.
        (V:vector2).IsFinite<public>()<computes><decides>:vector2 = external {}

        # Succeeds when each component of `V` is within `AbsoluteTolerance` of `0.0`.
        (V:vector2).IsAlmostZero<public>(AbsoluteTolerance:float)<computes><decides>:void = external {}

        # Succeeds when each component of `V1` and `V2` are within `AbsoluteTolerance` of each other.
        IsAlmostEqual<public>(V1:vector2, V2:vector2, AbsoluteTolerance:float)<computes><decides>:void = external {}

        # 2-dimensional vector with `int` components.
        vector2i<native><public> := struct<concrete><computes>:
            @editable
            X<native><public>:int = external {}

            @editable
            Y<native><public>:int = external {}

        # Returns the dot product of `V1` and `V2`.
        DotProduct<public>(V1:vector2i, V2:vector2i)<computes>:int = external {}

        # Makes a `vector2i` that is component-wise equal to `V1` and `V2`.
        # Fails if any component of `V1` does not equal the corresponding component of `V2`.
        Equals<public>(V1:vector2i, V2:vector2i)<computes><decides>:vector2i = external {}

        # Makes a `string` representation of `V`.
        ToString<native><public>(V:vector2i)<computes>:[]char

        # Makes a `vector2i` by component-wise truncation of `V` to `ints`s.
        ToVector2i<public>(V:vector2)<varies><decides>:vector2i = external {}

        # Makes a `vector2i` by inverting the signs of `Operand`.
        prefix'-'<public>(Operand:vector2i)<computes>:vector2i = external {}

        # Makes a `vector2i` by component-wise addition of `Left` and `Right`.
        operator'+'<public>(Left:vector2i, Right:vector2i)<computes>:vector2i = external {}

        # Makes a `vector2i` by component-wise subtraction of `Right` from `Left`.
        operator'-'<public>(Left:vector2i, Right:vector2i)<computes>:vector2i = external {}

        # Makes a `vector2i` by multiplying the components of `Left` by `Right`.
        operator'*'<public>(Left:vector2i, Right:int)<computes>:vector2i = external {}

        # Makes a `vector2i` by multiplying the components of `Right` by `Left`.
        operator'*'<public>(Left:int, Right:vector2i)<computes>:vector2i = external {}

        # 3-dimensional vector with `float` components.
        vector3<native><public> := struct<concrete><computes>:
            @editable
            X<native><public>:float = external {}

            @editable
            Y<native><public>:float = external {}

            @editable
            Z<native><public>:float = external {}

        # Makes a `vector3` by inverting the `SurfaceNormal` component of `Direction`.
        # Fails if `not SurfaceNormal.MakeUnitVector[]`.
        ReflectVector<native><public>(Direction:vector3, SurfaceNormal:vector3)<varies><decides>:vector3

        # Returns the dot product of `V1` and `V2`.
        DotProduct<native><public>(V1:vector3, V2:vector3)<varies>:float

        # Returns the cross product of `V1` and `V2`.
        CrossProduct<native><public>(V1:vector3, V2:vector3)<varies>:vector3

        # Returns the Euclidean distance between `V1` and `V2`.
        Distance<native><public>(V1:vector3, V2:vector3)<varies>:float

        # Returns the squared Euclidean distance between `V1` and `V2`.
        DistanceSquared<native><public>(V1:vector3, V2:vector3)<varies>:float

        # Returns the 2-D Euclidean distance between `V1` and `V2` by ignoring the difference in `Z`.
        DistanceXY<native><public>(V1:vector3, V2:vector3)<varies>:float

        # Returns the squared 2-D Euclidean distance between `V1` and `V2` by ignoring their difference in `Z`.
        DistanceSquaredXY<native><public>(V1:vector3, V2:vector3)<varies>:float

        # Makes a unit length `vector3` pointing in the same direction of `V`.
        # Fails if `V.IsAlmostZero[] or not V.IsFinite[]`.
        (V:vector3).MakeUnitVector<native><public>()<varies><decides>:vector3

        # Makes a `string` representation of `V`.
        ToString<native><public>(V:vector3)<varies>:[]char

        # Returns the length of `V`.
        (V:vector3).Length<public>()<varies>:float = external {}

        # Returns the squared length of `V`.
        (V:vector3).LengthSquared<public>()<computes>:float = external {}

        # Returns the length of `V` as if `V.Z = 0.0`.
        (V:vector3).LengthXY<public>()<varies>:float = external {}

        # Returns the squared length of `V` as if `V.Z = 0.0`.
        (V:vector3).LengthSquaredXY<public>()<varies>:float = external {}

        # Used to linearly interpolate/extrapolate between `From` (when `Parameter = 0.0`)
        # and `To` (when `Parameter = 1.0`). Expects that all arguments are finite.
        # Returns `From*(1 - Parameter) + To*Parameter`.
        Lerp<public>(From:vector3, To:vector3, Parameter:float)<varies>:vector3 = external {}

        # Makes a `vector3` by inverting the signs of `Operand`.
        prefix'-'<public>(Operand:vector3)<computes>:vector3 = external {}

        # Makes a `vector3` by component-wise addition of `Left` and `Right`.
        operator'+'<public>(Left:vector3, Right:vector3)<computes>:vector3 = external {}

        # Makes a `vector3` by component-wise subtraction of `Right` from `Left`.
        operator'-'<public>(Left:vector3, Right:vector3)<computes>:vector3 = external {}

        # Makes a `vector3` by component-wise multiplication of `Left` and `Right`.
        operator'*'<public>(Left:vector3, Right:vector3)<computes>:vector3 = external {}

        # Makes a `vector3` by multiplying the components of `Left` by `Right`.
        operator'*'<public>(Left:vector3, Right:float)<computes>:vector3 = external {}

        # Makes a `vector3` by multiplying the components of `Right` by `Left`.
        operator'*'<public>(Left:float, Right:vector3)<computes>:vector3 = external {}

        # Makes a `vector3` by dividing the components of `Left` by `Right`.
        operator'/'<public>(Left:vector3, Right:float)<computes>:vector3 = external {}

        # Returns `V` if all components are finite.
        # Fails if any of the components are not finite.
        (V:vector3).IsFinite<public>()<computes><decides>:vector3 = external {}

        # Succeeds when each component of `V` is within `AbsoluteTolerance` of `0.0`.
        (V:vector3).IsAlmostZero<public>(AbsoluteTolerance:float)<computes><decides>:void = external {}

        # Succeeds when each component of `V1` and `V2` are within `AbsoluteTolerance` of each other.
        IsAlmostEqual<public>(V1:vector3, V2:vector3, AbsoluteTolerance:float)<computes><decides>:void = external {}

    # Module import path: /UnrealEngine.com/Temporary/Diagnostics
    Diagnostics<public> := module:
        # log levels available for various log commands
        log_level<native><public> := enum:
            Debug
            Verbose
            Normal
            Warning
            Error

        # log_channel is the base class used to define log channels. When printing a message to a log, the log channel class name will be prefixed to the output message.
        log_channel<native><public> := class<abstract>:

        # log class to send messages to the default log
        log<native><public> := class:
            # Channel class name will be added as a prefix used when printing the message e.g. '[log_channel]: #Message
            Channel<native><public>:subtype(log_channel)

            # Sets the default log level of the displayed message. See log_level enum for more info on log levels. Defaults to log_level.Normal.
            DefaultLevel<native><public>:log_level = external {}

            # Print message using the given log level
            (log:)Print<native><public>(Message:[]char, ?Level:log_level = external {})<computes>:void

            # Prints current script call stack using the give log level
            PrintCallStack<native><public>(?Level:log_level = external {})<computes>:void

    # Module import path: /UnrealEngine.com/Temporary/Curves
    Curves<public> := module:
        editable_curve<native><public> := class<final>:
            # Evaluates this float curve at the specified time and returns the result as a float
            Evaluate<native><public>(Time:float):float

Verse.digest.verse

# Copyright Epic Games, Inc. All Rights Reserved.
#################################################
# Generated Digest of Verse API
# DO NOT modify this manually!
# Generated from build: ++Fortnite+Release-24.20-CL-25058254
#################################################

Simulation<public> := module:
    # Module import path: /Verse.org/Simulation/Tags
    Tags<public> := module:
        # A single gameplay tag, which represents a hierarchical name of the form x.y that is registered in the GameplayTagsManager You can filter the gameplay tags displayed in the editor.
        tag<native><public> := class<abstract>:

        # A queryable collection of gameplay tags.
        tag_view<native><public> := interface<epic_internal>:
            # Determine if TagToCheck is present in this container, also checking against parent tags {"A.1"}.Has("A") will return True, {"A"}.Has("A.1") will return False If TagToCheck is not Valid it will always return False.
            Has<public>(TagToCheck:tag)<transacts><decides>:void

            # Checks if this container contains ANY of the tags in the specified container, also checks against parent tags {"A.1"}.HasAny({"A","B"}) will return True, {"A"}.HasAny({"A.1","B"}) will return False If InTags is empty/invalid it will always return False.
            HasAny<public>(InTags:[]tag)<transacts><decides>:void

            # Checks if this container contains ALL of the tags in the specified container, also checks against parent tags {"A.1","B.1"}.HasAll({"A","B"}) will return True, {"A","B"}.HasAll({"A.1","B.1"}) will return False If InTags is empty/invalid it will always return True, because there were no failed checks.
            HasAll<public>(InTags:[]tag)<transacts><decides>:void

        tag_search_sort_type<native><public> := enum:
            Unsorted
            Sorted

        # Advanced tag search criteria
        tag_search_criteria<native><public> := class:
            # Tags required to be on the object.
            RequiredTags<native><public>:[]tag = external {}

            # Tags that are used if no required tags are specified. These are treated as if any of them will do.
            PreferredTags<native><public>:[]tag = external {}

            # Tags that may NOT be on the object. All items with these tags are excluded from the search.
            ExclusionTags<native><public>:[]tag = external {}

            # Flag to request sorting the results by tag.
            SortType<native><public>:tag_search_sort_type = external {}

    @attribscope_class
    @attribscope_struct
    @attribscope_data
    @customattribhandler
    editable<public> := class(attribute):

    agent<native><public> := class<unique><epic_internal>:

    player<native><public> := class<unique><epic_internal>(agent):

    # Waits specified number of seconds and then resumes. If `Seconds` = 0.0 then it waits until next tick/frame/update. If `Seconds` = Inf then it waits forever and only calls back if canceled - such as via `race`. If `Seconds` < 0.0 then it completes immediately and does not yield to other aysnc expressions.
    # Waiting until the next update (0.0) is especially useful in a loop of a coroutine that needs to do some work every update and this yields to other coroutines so that it doesn't hog a processor's resources.
    # Waiting forever (Inf) will have any expression that follows never be evaluated. Occasionally it is desireable to have a task never complete such as the last expression in a `race` subtask where the task must never win the race though it still may be canceled earlier.
    # Immediately completing (less than 0) is useful when you want programmatic control over whether an expression yields or not.
    Sleep<native><public>(Seconds:float)<suspends>:void

    # Get the seconds that have elapsed since the world began simulating
    GetSimulationElapsedTime<native><public>()<transacts>:float

    team<native><public> := class<unique><epic_internal>:

# Module import path: /Verse.org/Assets
Assets<public> := module:

using {/Verse.org/Colors}
using {/Verse.org/Concurrency}
# Module import path: /Verse.org/Verse
Verse<public> := module:
    # Makes a flattened `array` by concatenating the elements of `Arrays`.
    Concatenate<public>(Arrays:[][]t where t:type)<computes>:[]t = external {}

    # Makes an `array` containing `Input`'s elements from `StartIndex` to `StopIndex-1`.
    # Fails unless `0 <= StartIndex <= StopIndex <= Input.Length`.
    (Input:[]t where t:type).Slice<public>(StartIndex:int, StopIndex:int)<computes><decides>:[]t = external {}

    # Makes an `array` containing `Input`'s elements from `StartIndex` to `Input.Length-1`.
    # Succeeds if `0 <= StartIndex <= Input.Length`.
    (Input:[]t where t:type).Slice<public>(StartIndex:int)<computes><decides>:[]t = external {}

    # Makes an `array` by inserting `ElementsToInsert` into `Input` such that the first element of `ElementsToInsert` is at `InsertionIndex`.
    (Input:[]t where t:type).Insert<public>(InsertionIndex:int, ElementsToInsert:[]t)<computes><decides>:[]t = external {}

    # Makes an `array` by removing the element at `IndexToRemove` from `Input`.
    # Succeeds if `0 <= IndexToRemove <= Input.Length-1`.
    (Input:[]t where t:type).RemoveElement<public>(IndexToRemove:int)<computes><decides>:[]t = external {}

    # Makes an `array` by removing the element at the lowest index that equals `ElementToRemove` from `Input`.
    # Fails if `Input` did not contain any instances of `ElementToRemove`.
    (Input:[]t where t:subtype(comparable)).RemoveFirstElement<public>(ElementToRemove:t)<computes><decides>:[]t = external {}

    # Makes an `array` by removing all elements that equal `ElementToRemove` from `Input`.
    (Input:[]t where t:subtype(comparable)).RemoveAllElements<public>(ElementToRemove:t)<computes>:[]t = external {}

    # Makes an `array` by replacing the element at `IndexToReplace` with `ElementToReplaceWith` in `Input`.
    # Succeeds if `0 <= IndexToReplace <= Input.Length-1`.
    (Input:[]t where t:type).ReplaceElement<public>(IndexToReplace:int, ElementToReplaceWith:t)<computes><decides>:[]t = external {}

    # Makes an `array` by replacing the element at the lowest index that equals `ElementToReplace` with `ElementToReplaceWith` in `Input`.
    # Fails if `Input` did not contain any instances of `ElementToReplace`.
    (Input:[]t where t:subtype(comparable)).ReplaceFirstElement<public>(ElementToReplace:t, ElementToReplaceWith:t)<computes><decides>:[]t = external {}

    # Makes an `array` by replacing all elements that equal `ElementToReplace` with `ElementToReplaceWith` in `Input`.
    (Input:[]t where t:subtype(comparable)).ReplaceAllElements<public>(ElementToReplace:t, ElementToReplaceWith:t)<computes>:[]t = external {}

    # Makes an `array` by replacing all ranges of elements that equal `ElementsToReplace` with `Replacement` in `Input`.
    # When there are multiple overlapping instances of `ElementsToReplace` in `Input`, only the position with the lowest
    # index is replaced.
    (Input:[]t where t:subtype(comparable)).ReplaceAll<public>(ElementsToReplace:[]t, Replacement:[]t)<transacts>:[]t = external {}

    # Makes an `array` by removing `Input`'s elements from `StartIndex` to `StopIndex-1`.
    # Succeeds if `0 <= StartIndex <= StopIndex <= Input.Length`.
    (Input:[]t where t:type).Remove<public>(StartIndex:int, StopIndex:int)<computes><decides>:[]t = external {}

    # Returns the first index whose element in `Input` equals `ElementToFind`.
    # Fails if ElementToFind does not exist in the array.
    (Input:[]t where t:subtype(comparable)).Find<public>(ElementToFind:t)<computes><decides>:int = external {}

    # Implemented by classes that allow users to cancel an operation. For example, calling
    # `subscribable.Subscribe` with a callback returns a `cancelable` object. Calling `Cancel`
    # on the return object unsubscribes the callback.
    cancelable<native><public> := interface:
        # Prevents any current or future work from completing.
        Cancel<public>()<transacts>:void

    # Implemented by classes whose instances have limited lifetimes.
    disposable<native><public> := interface:
        # Cleans up this object.
        Dispose<public>():void

    # Halts the Verse runtime with error `Message`.
    Err<native><public>(Message:[]char)<computes>:false

    # A *recurring*, successively signaled parametric `event` with a `payload` allowing a
    # simple mechanism to coordinate between concurrent tasks:
    #  * `Await` suspends tasks to wait on this `event`,
    #  * another task `Signal`s this `event` and resumes the suspended tasks in FIFO order.
    event<native><public>(t:type)<computes> := class(signalable(t), awaitable(t)):
        # Suspends the current task until another task calls `Signal`.
        # If called during another invocation of `Signal`, the the task will still suspend
        # and resume during the next call to `Signal`.
        Await<native><override>()<suspends>:t

        # Concurrently resumes the tasks that were suspended by `Await` calls before this
        # call to `Signal`.
        # 
        # Tasks are resumed in the order they were suspended. Each task will perform as
        # much work as it can until it encounters a blocking call, whereupon it will
        # transfer control to the next suspended task.
        Signal<native><override>(Val:t):void

    # A *recurring*, successively signaled event allowing a simple mechanism to coordinate
    # between concurrent tasks.
    event<public>()<computes> := event(tuple())

    # Returns the smallest `int` that is greater than or equal to `Val`.
    # Fails if `not IsFinite(Val)`.
    Ceil<native><public>(Val:float)<varies><decides>:int

    # Returns the largest `int` that is less than or equal to `Val`.
    # Fails if `not IsFinite(Val)`.
    Floor<native><public>(Val:float)<varies><decides>:int

    # Returns `Val` rounded to the nearest `int`. When the fractional part of `Val` is `0.5`,
    # rounds to the nearest *even* `int` (per the IEEE-754 default rounding mode).
    # Fails if `not IsFinite(Val)`.
    Round<native><public>(Val:float)<varies><decides>:int

    # Returns the `int` that equals `Val` without the fractional part
    # Fails if `not IsFinite(val)`.
    Int<native><public>(Val:float)<varies><decides>:int

    # Makes a `string` representation of `Val`.
    ToString<native><public>(Val:float)<varies>:[]char

    # Makes a printable `string` representation of `Val`.
    ToString<native><public>(Val:int)<computes>:[]char

    # Implemented by classes whose instances can become invalid at runtime.
    invalidatable<native><public> := interface(disposable):
        # Succeeds if this object is still valid.
        IsValid<public>()<transacts><decides>:void

    # A parametric interface combining `awaitable` and `subscribable`.
    listenable<public>(payload:type)<computes> := interface(awaitable(payload), subscribable(payload)):

    # A parameterless interface combining `awaitable` and `subscribable`.
    listenable<public>()<computes> := listenable(tuple())

    # Used for message localization.
    locale<native><public> := struct<computes><epic_internal>:

    # A localizable text message.
    message<native><public> := class<computes><epic_internal>:

    # Makes a `string` by localizing `Message` based on the current `locale`.
    Localize<native_callable><public>(Message:message)<varies>:[]char = external {}

    localizable_value<epic_internal> := interface:

    localizable_string<epic_internal> := class<computes><internal>(localizable_value):

    MakeLocalizableValue<epic_internal>(V:[]char)<computes>:localizable_string = external {}

    localizable_int<epic_internal> := class<computes><internal>(localizable_value):

    MakeLocalizableValue<epic_internal>(V:int)<computes>:localizable_int = external {}

    localizable_float<epic_internal> := class<computes><internal>(localizable_value):

    MakeLocalizableValue<epic_internal>(V:float)<computes>:localizable_float = external {}

    MakeMessageInternal<native><epic_internal>(K:[]char, D:[]char, S:[[]char]localizable_value)<converges>:message

    # Pi, the ratio of the circumference of a circle to its diameter.
    PiFloat<public>:float = external {}

    # Constrains the value of `Val` between `A` and `B`. Robustly handles different argument orderings.
    # Returns the median of `Val`, `A`, and `B`, such that comparisons with `NaN` operate as if `NaN > +Inf`.
    Clamp<public>(Val:float, A:float, B:float)<computes>:float = external {}

    # Constrains the value of `Val` between `A` and `B`. Robustly handles different argument orderings.
    # Returns the median of `Val`, `A`, and `B`.
    Clamp<native><public>(Val:int, A:int, B:int)<computes>:int

    # Returns the minimum of `X` and `Y`.
    Min<public>(X:int, Y:int)<computes>:int = external {}

    # Returns the maximum of `X` and `Y`.
    Max<public>(X:int, Y:int)<computes>:int = external {}

    # Returns the minimum of `X` and `Y` unless either are `NaN`.
    # Returns `NaN` if either `X` or `Y` are `NaN`.
    Min<public>(X:float, Y:float)<computes>:float = external {}

    # Returns the maximum of `X` and `Y` unless either are `NaN`.
    # Returns `NaN` if either `X` or `Y` are `NaN`.
    Max<public>(X:float, Y:float)<computes>:float = external {}

    # Returns the square root of `X` if `X >= 0.0`.
    # Returns `NaN` if `X < 0.0`.
    Sqrt<native><public>(X:float)<varies>:float

    # Returns the sine of `X` if `IsFinite(X)`.
    # Returns `NaN` if `not IsFinite(X)
    Sin<native><public>(X:float)<varies>:float

    # Returns the cosine of `X` if `IsFinite(X)`.
    # Returns `NaN` if `not IsFinite(X)
    Cos<native><public>(X:float)<varies>:float

    # Returns the tangent of `X` if `IsFinite(X)`.
    # Returns `NaN` if `not IsFinite(X).
    Tan<native><public>(X:float)<varies>:float

    # Returns the inverse sine (arcsine) of `X` if `-1.0 <= X <= 1.0`.
    ArcSin<native><public>(X:float)<varies>:float

    # Returns the inverse cosine (arccosine) of `X` if `-1.0 <= X <= 1.0`.
    ArcCos<native><public>(X:float)<varies>:float

    # Returns the inverse tangent (arctangent) of `X` such that:
    # `-PiFloat/2.0 <= ArcTan(x) <= PiFloat/2.0`.
    ArcTan<native><public>(X:float)<varies>:float

    # Returns the angle in radians at the origin between a ray pointing to `(X, Y)`
    # and the positive `X` axis such that `-PiFloat < ArcTan(Y, X) <= PiFloat`.
    # Returns 0.0 if `X=0.0 and Y=0.0`.
    ArcTan<native><public>(Y:float, X:float)<varies>:float

    # Returns the hyperbolic sine of `X`.
    Sinh<native><public>(X:float)<varies>:float

    # Returns the hyperbolic cosine of `X`.
    Cosh<native><public>(X:float)<varies>:float

    # Returns the hyperbolic tangent of `X`.
    Tanh<native><public>(X:float)<varies>:float

    # Returns the inverse hyperbolic sine of `X` if `IsFinite(X)`.
    ArSinh<native><public>(X:float)<varies>:float

    # Returns the inverse hyperbolic cosine of `X` if `1.0 <= X`.
    ArCosh<native><public>(X:float)<varies>:float

    # Returns the inverse hyperbolic tangent of `X` if `IsFinite(X)`.
    ArTanh<native><public>(X:float)<varies>:float

    # Returns `A` to the power of `B`.
    Pow<native><public>(A:float, B:float)<varies>:float

    # Returns `X` if `X` is finite.
    # Fails if `X` is one of:`
    #  * `+Inf`
    #  * `-Inf`
    #  * `NaN`
    (X:float).IsFinite<public>()<computes><decides>:float = external {}

    # Returns the quotient `X/Y` as defined by Euclidean division, i.e.:
    #  * `Quotient[X/Y] = Floor[X/Y]` when `Y > 0`
    #  * `Quotient[X/Y] = Ceil[X/Y]` when `Y < 0`
    #  * `Quotient[X/Y] * Y + Mod[X,Y] = X`
    # Fails if `Y = 0`.
    Quotient<native><public>(X:int, Y:int)<computes><decides>:int

    # Returns the remainder of `X/Y` as defined by Euclidean division, i.e.:
    #  * `Mod[X,Y] = X - Quotient(X/Y)*Y`
    #  * `0 <= Mod[X,Y] < Abs(Y)`
    # Fails if `Y=0`.
    Mod<native><public>(X:int, Y:int)<computes><decides>:int

    # Returns the natural exponent of `X`.
    Exp<native><public>(X:float)<varies>:float

    # Returns the natural logarithm of `X`.
    Ln<native><public>(X:float)<varies>:float

    # Returns the base `B` logarithm of `X`.
    Log<public>(B:float, X:float)<varies>:float = external {}

    # Used to linearly interpolate/extrapolate between `From` (when `Parameter = 0.0`)
    # and `To` (when `Parameter = 1.0`). Expects that all arguments are finite.
    # Returns `From*(1 - Parameter) + To*Parameter`.
    Lerp<native><public>(From:float, To:float, Parameter:float)<varies>:float

    # Returns the sign of `Val`:
    #  * `1` if `Val > 0`
    #  * `0` if `Val = 0`
    #  * `-1` if `Val < 0`
    Sgn<public>(Val:int)<computes>:int = external {}

    # Returns the sign of `Val`:
    #  * `1.0` if `Val > 0.0`
    #  * `0.0` if `Val = 0.0`
    #  * `-1.0` if `Val < 0.0`
    #  * `NaN` if `Val = NaN`
    Sgn<public>(Val:float)<computes>:float = external {}

    # Succeeds if `Val` is within `AbsoluteTolerance` of `0.0`.
    (Val:float).IsAlmostZero<public>(AbsoluteTolerance:float)<computes><decides>:void = external {}

    # Succeeds if `Val1` and `Val2` are within `AbsoluteTolerance` of each other.
    IsAlmostEqual<public>(Val1:float, Val2:float, AbsoluteTolerance:float)<computes><decides>:void = external {}

    # Writes `Message` to a dedicated `Print` log while displaying it in `Color` on the
    # client screen for `Duration` seconds. By default, `Color` is `NamedColors.White` and
    # `Duration` is `2.0` seconds.
    Print<native><public>(Message:[]char, ?Duration:float = external {}, ?Color:color = external {}):void

    # A parametric interface implemented by events with a `payload` that can be signaled.
    # Can be used with `awaitable`, `subscribable`, or both (see: `listenable`).
    signalable<public>(payload:type)<computes> := interface:
        # Concurrently resumes the tasks waiting for this event in `awaitable.Await` and 
        # synchronously invokes any callbacks added to this event by `subscribable.Subscribe`.
        Signal<public>(Val:payload):void

    # Makes a `string` by concatenating `Separator` between the elements of `Strings`.
    Join<native><public>(Strings:[][]char, Separator:[]char)<computes>:[]char

    # Returns `String` without modification.
    ToString<public>(String:[]char)<computes>:[]char = external {}

    # Makes a `string` from `Character`.
    ToString<native><public>(Character:char)<computes>:[]char

    # A parametric interface implemented by events with a `payload` that can be subscribed to.
    # Matched with `signalable.`
    subscribable<public>(t:type)<computes> := interface:
        # Registers `Callback` to be invoked on matching calls to `signable.Signal`.
        # Returns an unsubscriber object. Call `cancelable.Cancel` on the unsubscriber to unregister `Callback`.
        Subscribe<public>(Callback:type {__(:t):void})<transacts>:cancelable

    # A parameterless interface implemented by events that can be subscribed to.
    subscribable<public>()<computes> := subscribable(tuple())

# Module import path: /Verse.org/Random
Random<public> := module:
    # Returns a random `float` between `Low` and `High`, inclusive.
    GetRandomFloat<native><public>(Low:float, High:float)<varies>:float

    # Returns a random `int` between `Low` and `High`, inclusive.
    GetRandomInt<native><public>(Low:int, High:int)<varies>:int

    # Makes an `array` with the same elements as `Input` shuffled in a random order.
    Shuffle<public>(Input:[]t where t:type)<transacts>:[]t = external {}

# Module import path: /Verse.org/Colors
Colors<public> := module:
    # Represents colors as RGB triples in the ACES 2065-1 color space.
    # Component values are linear (i.e. `*gamma* = 1.0`).
    color<native><public> := struct<computes>:
        # Red component of this `color`.
        R<native><public>:float = external {}

        # Green component of this `color`.
        G<native><public>:float = external {}

        # Blue component of this `color`.
        B<native><public>:float = external {}

    # Makes an ACES 2065-1 `color` from the component-wise sum of `c0` and `c1`.
    operator'+'<native><public>(c0:color, c1:color)<converges>:color

    # Makes an ACES 2065-1 `color` from the component-wise difference of `c0` and `c1`.
    operator'-'<native><public>(c0:color, c1:color)<converges>:color

    # Makes an ACES 2065-1 `color` from the component-wise product of `c0` and `c1`.
    operator'*'<native><public>(c0:color, c1:color)<converges>:color

    # Makes an ACES 2065-1 `color` from each component of `c` scaled by `factor`.
    operator'*'<native><public>(c:color, factor:float)<converges>:color

    # Makes an ACES 2065-1 `color` from each component of `c` scaled by `factor`.
    operator'*'<native><public>(c:color, factor:int)<converges>:color

    # Makes an ACES 2065-1 `color` from each component of `c` scaled by `factor`.
    operator'*'<native><public>(factor:float, c:color)<converges>:color

    # Makes an ACES 2065-1 `color` from each component of `c` scaled by `factor`.
    operator'*'<native><public>(factor:int, c:color)<converges>:color

    # Makes an ACES 2065-1 `color` from each component of `c` divided by `factor`.
    operator'/'<native><public>(c:color, factor:float)<computes><decides>:color

    # Makes an ACES 2065-1 `color` from each component of `c` divided by `factor`.
    operator'/'<native><public>(c:color, factor:int)<computes><decides>:color

    # Makes an ACES 2065-1 `color` from sRGB components `Red`, `Green`, and `Blue`.
    # Normal sRGB component values are between `0.0` and `1.0`, but this can handle
    # larger values.
    MakeColorFromSRGB<native><public>(Red:float, Green:float, Blue:float)<converges>:color

    # Makes an sRGB `tuple` by converting `InColor` from an ACES 2065-1 `color` to sRGB.
    MakeSRGBFromColor<native><public>(InColor:color)<converges>:tuple(float, float, float)

    # Makes an ACES 2065-1 `color` from the integer sRGB components `Red`, `Green`, and `Blue`.
    # Valid sRGB component values are between '0' and '255', inclusive.
    MakeColorFromSRGBValues<native><public>(Red:int, Green:int, Blue:int)<converges>:color

    # Makes an ACES 2065-1 `color` from a CSS-style sRGB `hexString`. Supported formats are:
    #  * RGB
    #  * RRGGBB
    #  * RRGGBBAA
    #  * #RGB
    #  * #RRGGBB
    #  * #RRGGBBAA
    # An invalid hex string will return `Black`.
    MakeColorFromHex<native><public>(hexString:[]char)<converges>:color

    # Makes an ACES 2065-1 `color` from `Hue`, `Saturation`, and `Value` components.
    # Components use the HSV color model in the sRGB color space. Expected ranges:
    #  * `0.0 <= Hue <= 360.0`
    #  * `0.0 <= Saturation <= 1.0`
    #  * `0.0 <= Value <= 1.0`
    # Values out of expected ranges will undergo range reduction and conversion.
    MakeColorFromHSV<native><public>(Hue:float, Saturation:float, Value:float)<converges>:color

    # Makes an HSV `tuple` by converting `InColor` from an ACES 2065-1 `color` to sRGB and applying the HSV color model.
    MakeHSVFromColor<native><public>(InColor:color):tuple(float, float, float)

    # Makes an ACES 2065-1 `color` from the chromaticty of a blackbody radiator at `Temperature` Kelvin.
    # `Temperature` is clamped such that `0 <= Temperature`.
    MakeColorFromTemperature<native><public>(Temperature:float)<converges>:color

    # Module import path: /Verse.org/Colors/NamedColors
    # Color presets from CSS Color Module 3 Extended color keywords.
    NamedColors<public> := module:
        AliceBlue<public>:color = external {}

        AntiqueWhite<public>:color = external {}

        Aqua<public>:color = external {}

        Aquamarine<public>:color = external {}

        Azure<public>:color = external {}

        Beige<public>:color = external {}

        Bisque<public>:color = external {}

        Black<public>:color = external {}

        BlanchedAlmond<public>:color = external {}

        Blue<public>:color = external {}

        BlueViolet<public>:color = external {}

        Brown<public>:color = external {}

        Burlywood<public>:color = external {}

        CadetBlue<public>:color = external {}

        Chartreuse<public>:color = external {}

        Chocolate<public>:color = external {}

        Coral<public>:color = external {}

        CornflowerBlue<public>:color = external {}

        Cornsilk<public>:color = external {}

        Crimson<public>:color = external {}

        Cyan<public>:color = external {}

        DarkBlue<public>:color = external {}

        DarkCyan<public>:color = external {}

        DarkGoldenrod<public>:color = external {}

        DarkGray<public>:color = external {}

        DarkGreen<public>:color = external {}

        DarkGrey<public>:color = external {}

        DarkKhaki<public>:color = external {}

        DarkMagenta<public>:color = external {}

        DarkOliveGreen<public>:color = external {}

        DarkOrange<public>:color = external {}

        DarkOrchid<public>:color = external {}

        DarkRed<public>:color = external {}

        DarkSalmon<public>:color = external {}

        DarkSeaGreen<public>:color = external {}

        DarkSlateBlue<public>:color = external {}

        DarkSlateGray<public>:color = external {}

        DarkSlateGrey<public>:color = external {}

        DarkTurquoise<public>:color = external {}

        DarkViolet<public>:color = external {}

        DeepPink<public>:color = external {}

        DeepSkyBlue<public>:color = external {}

        DimGray<public>:color = external {}

        DimGrey<public>:color = external {}

        DodgerBlue<public>:color = external {}

        Firebrick<public>:color = external {}

        FloralWhite<public>:color = external {}

        ForestGreen<public>:color = external {}

        Fuchsia<public>:color = external {}

        Gainsboro<public>:color = external {}

        GhostWhite<public>:color = external {}

        Gold<public>:color = external {}

        Goldenrod<public>:color = external {}

        Gray<public>:color = external {}

        Green<public>:color = external {}

        GreenYellow<public>:color = external {}

        Grey<public>:color = external {}

        Honeydew<public>:color = external {}

        Hotpink<public>:color = external {}

        IndianRed<public>:color = external {}

        Indigo<public>:color = external {}

        Ivory<public>:color = external {}

        Khaki<public>:color = external {}

        Lavender<public>:color = external {}

        LavenderBlush<public>:color = external {}

        LawnGreen<public>:color = external {}

        LemonChiffon<public>:color = external {}

        LightBlue<public>:color = external {}

        LightCoral<public>:color = external {}

        LightCyan<public>:color = external {}

        LightGoldenrodYellow<public>:color = external {}

        LightGray<public>:color = external {}

        LightGreen<public>:color = external {}

        LightGrey<public>:color = external {}

        LightPink<public>:color = external {}

        LightSalmon<public>:color = external {}

        LightSeaGreen<public>:color = external {}

        LightSkyBlue<public>:color = external {}

        LightSlateGray<public>:color = external {}

        LightSlateGrey<public>:color = external {}

        LightSteelBlue<public>:color = external {}

        LightYellow<public>:color = external {}

        Lime<public>:color = external {}

        LimeGreen<public>:color = external {}

        Linen<public>:color = external {}

        Magenta<public>:color = external {}

        Maroon<public>:color = external {}

        MediumAquamarine<public>:color = external {}

        MediumBlue<public>:color = external {}

        MediumOrchid<public>:color = external {}

        MediumPurple<public>:color = external {}

        MediumSeaGreen<public>:color = external {}

        MediumSlateBlue<public>:color = external {}

        MediumSpringGreen<public>:color = external {}

        MediumTurquoise<public>:color = external {}

        MediumVioletRed<public>:color = external {}

        MidnightBlue<public>:color = external {}

        MintCream<public>:color = external {}

        MistyRose<public>:color = external {}

        Moccasin<public>:color = external {}

        NavajoWhite<public>:color = external {}

        Navy<public>:color = external {}

        OldLace<public>:color = external {}

        Olive<public>:color = external {}

        OliveDrab<public>:color = external {}

        Orange<public>:color = external {}

        OrangeRed<public>:color = external {}

        Orchid<public>:color = external {}

        PaleGoldenrod<public>:color = external {}

        PaleGreen<public>:color = external {}

        PaleTurquoise<public>:color = external {}

        PaleVioletred<public>:color = external {}

        PapayaWhip<public>:color = external {}

        PeachPuff<public>:color = external {}

        Peru<public>:color = external {}

        Pink<public>:color = external {}

        Plum<public>:color = external {}

        PowderBlue<public>:color = external {}

        Purple<public>:color = external {}

        Red<public>:color = external {}

        RosyBrown<public>:color = external {}

        RoyalBlue<public>:color = external {}

        SaddleBrown<public>:color = external {}

        Salmon<public>:color = external {}

        SandyBrown<public>:color = external {}

        SeaGreen<public>:color = external {}

        SeaShell<public>:color = external {}

        Sienna<public>:color = external {}

        Silver<public>:color = external {}

        SkyBlue<public>:color = external {}

        SlateBlue<public>:color = external {}

        SlateGray<public>:color = external {}

        SlateGrey<public>:color = external {}

        Snow<public>:color = external {}

        SpringGreen<public>:color = external {}

        SteelBlue<public>:color = external {}

        (NamedColors:)Tan<public>:color = external {}

        Teal<public>:color = external {}

        Thistle<public>:color = external {}

        Tomato<public>:color = external {}

        Turquoise<public>:color = external {}

        Violet<public>:color = external {}

        Wheat<public>:color = external {}

        White<public>:color = external {}

        WhiteSmoke<public>:color = external {}

        Yellow<public>:color = external {}

        YellowGreen<public>:color = external {}

# Module import path: /Verse.org/Native
Native<public> := module:
    @attribscope_class
    @attribscope_struct
    import_as_attribute<epic_internal> := class(attribute):

    import_as<epic_internal>(importName:[]char)<computes>:import_as_attribute

# Module import path: /Verse.org/Concurrency
Concurrency<public> := module:
    # A parametric interface implemented by events with a `payload` that can be waited on. Matched with `signalable.`
    awaitable<public>(payload:type)<computes> := interface:
        # Suspends the current task until resumed by a matching call to `signalable.Signal`. Returns the event `payload`.
        Await<public>()<suspends>:payload

    awaitable<public>()<computes> := awaitable(void)

    task<native><public>(t:type)<computes> := class<abstract><final>(awaitable(t)):
        Await<native><override>()<suspends>:t