lib

    -- Example
    -- Import the blips module
    local Map = Import 'blips' --[[@as BLIPS]] 
    
    local blip = Map.Blips:Create('radius', { -- type can be entity, coords, area, radius
        Entity = ped, -- if type is entity, you need to provide a handle
        Pos = vector3(2865.88, 475.38, 66.09), -- position
        Radius = 50.0,                         -- if type is radius or area
        P7 = 0,                                -- optional default is 0
        Blip = 1673015813,                     -- blip hash the style of the blip
        Scale = vector3(1.0, 1.0, 1.0),        -- for type area only
        Options = {                            -- optional
            sprite = 1,                        --string or integer if type is entity or coords
            name = 'Test',
            modifier = 'BLIP_MODIFIER_MP_COLOR_1', -- int or string
            color = 'blue', -- internal color name 
        },
        OnCreate = function(self)
            print('Created', self:GetHandle())
            local blue, red, yellow = self:GetBlipColor({ 'blue', 'red', 'yellow' })
            self:AddModifier(red)
        end
    })

    local handle = blip:GetHandle()
    blip:Remove()

    -- Example
    -- Import the inputs module
    local controls = Import 'inputs' --[[@as INPUTS]] 
    
    -- Multiple input support
    local inputs = {
        { inputType = "Press",   key = "E" },
        { inputType = "Hold",    key = "W" },
        { inputType = "Release", key = "S" },
    }

    local input = controls.Inputs:Register(inputs,function(input, customParams)
        if input.key == "E" then
            print("E was pressed")
        elseif input.key == "W" then
            print("W is being held")
        elseif input.key == "S" then
            print("S was released")
        end
    end, true) -- auto start on register

    input:Destroy()

    -- Example
    -- Import the prompts module
    local Game = Import 'prompts' --[[@as PROMPTS]] 
    
    local data = {
        locations = {
            { -- index 1
                coords = vector3(2868.43, 480.19, 65.02), -- distance based prompts
                label = 'group label', -- group label
                distance = 2.0, -- distance from coords
                marker = { -- optional marker
                    type = 0x94FDAE17,
                    color = { r = 0, g = 255, b = 0, a = 96 },
                    distance = 4.0,
                    scale = { x = 2.0, y = 2.0, z = 0.5 },
                }
            }
        },
        sleep = 700, -- sleep time when not in range
        prompts = { -- group prompts or single prompt
            { type = 'Press', key = 'G', label = 'press', mode = 'Standard' },
            { type = 'Hold',  key = 'E', label = 'hold',  mode = 'Hold', holdTime = 3000 }
        }
    }

    local prompt = Game.Prompts:Register(data, function(prompt, index , self)
        -- first array, allows to use one location with multiple prompts
        if index == 1 then
            if prompt.key == 'G' then
                print('G pressed')
            elseif prompt.key == 'E' then
                print('E held for 3 seconds')
            end
        end
    end, true) -- auto start on register

    prompt:Destroy() -- the lib it self will destroy any prompt on script restart

    -- Example
    -- Import the commands module
    local Commands = Import 'commands' --[[@as COMMANDS]] 
    
    local command = Commands.Command:Register("mycommand", {
        Suggestion = { -- optional
            Description = "My custom command description",
            Arguments = {
                -- if type is number or integer, it will be converted to a number
                -- if type is message, it will give it as a message 
                { name = "playerId", help = "Target player ID", type = "integer", required = true },
                { name = "amount", help = "Amount value", type = "number", required = true },
                { name = "message", help = "Optional message", type = "message"}
            }
        },

        Permissions = { -- optional
            Ace = "group.admin" -- Restrict to admin group, or remove for public command
        },

        OnExecute = function(args, rawCommand, instance)
            print("Command executed with args:", json.encode(args))
            print("Player ID:", args[1]) -- integer type
            print("Amount:", args[2])     -- number type  
            print("Message:", args[3])    -- message type (remaining args combined)
        end,

        OnError = function(errorType)
            if errorType == 'missing_arguments' then
                print('Usage: /mycommand <playerId> <amount> [message]')
            elseif errorType == 'missing_permission' then
                print('You do not have permission to use this command')
            elseif errorType == 'command_active' then
                print('Command is currently paused')
            end
        end
    }, true) -- Auto-start

    -- Control methods
    command:Start(true)       -- Start and add suggestion if not have been added yet
    command:Destroy()         -- Clean up completely

    -- Argument types:
    -- "integer" - converts to number (whole numbers)
    -- "number" - converts to number (decimals allowed)  
    -- "message" - combines remaining arguments into string
    -- (no type) - keeps as string

    -- Error types:
    -- "missing_arguments" - Required argument not provided
    -- "missing_permission" - User lacks required permissions
    -- "command_active" - Command is paused
    -- "missing_target" - Target not found (if applicable)

    -- Example
    -- Import the points module
    local GamePoints = Import 'points' --[[@as POINTS]] 
    
    local points = GamePoints.Points:Register({
        Arguments = {
            {
                id = 'bank_entrance',                        -- unique identifier
                center = vector3(2843.49, 474.49, 64.03), -- center coordinates
                radius = 15.0,                             -- detection radius
                wait = 500,                                -- check interval (ms)
                debug = true,                              -- show debug marker
                deActivate = true,                        -- start active? remove to start active
            },
            {
                id = 'shop_door',
                center = vector3(2884.03, 484.19, 66.73),
                radius = 10.0,
                wait = 300,
                debug = true,
            },
        },

        OnEnter = function(point, distance)
            print("Entered point:", point.id, "Distance:", distance)
            if point.id == 'bank_entrance' then
                print("Welcome to the bank!")
            elseif point.id == 'shop_door' then
                print("Welcome to the shop!")
            end
        end,

        OnExit = function(point, distance)
            print("Exited point:", point.id, "Distance:", distance)
            if point.id == 'bank_entrance' then
                print("Left the bank area")
            elseif point.id == 'shop_door' then
                print("Left the shop area")
            end
        end
    }, true) -- Auto-start

    -- Control methods
    points:PausePoint('shop_door')        -- Pause specific point
    points:ResumePoint('shop_door')       -- Resume specific point
    points:RemovePoint('bank_entrance')   -- Remove specific point
    
    -- Check point status
    local isActive = points:IsPointActive('shop_door')
    local isInside = points:IsPointInside('shop_door')
    local isOutside = points:IsPointOutside('shop_door')
    
    -- System control
    points:Pause()   -- Pause entire system
    points:Resume()  -- Resume entire system
    points:Destroy() -- Clean up completely

    local PolyZones = Import('polyzones').PolyZones
    local zone = PolyZones:Register({
        id = 'temp_zone',
        type = 'circle',
        center = vector3(-100.0, 120.0, 40.0),
        radius = 3.0,
    }, true)

    PolyZones:Destroy(zone)