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
        },
       
            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, location)
        -- location is the current entry from data.locations[index]
        if index == 1 and location.label == 'group label' 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
        },

        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,

       
            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,
            },
        },

        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,

        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)

    -- Example
    -- Import the events module
    local Game = Import 'events' --[[@as EVENTS]]

    -- Register event with automatic data parsing
    local event = Game.Events:Register('EVENT_PED_CREATED', 0, function(data)
        print("Ped created with data:", json.encode(data, {indent = true}))
    end, true) -- Auto-start

    -- Developer mode for debugging, dont fire this events when in dev mode
    event:DevMode(true, {"EVENT_PED_CREATED","EVENT_VEHICLE_CREATED"}) -- Enable dev mode, ignore these events
    -- dev mode enables all events to be triggered

    -- Clean up
    event:Destroy()

    -- Import the dataview module
    local Data = Import 'dataview' --[[@as DATAVIEW]]

    -- Create a 64-byte buffer
    local buffer = Data.DataView.ArrayBuffer(64)

    -- Write different data types
    buffer:SetInt32(0, 42)           -- Write integer at offset 0
    buffer:SetFloat32(4, 3.14159)    -- Write float at offset 4
    buffer:SetString(8, "Hello")     -- Write string at offset 8

    -- Read the data back
    local intValue = buffer:GetInt32(0)       -- 42
    local floatValue = buffer:GetFloat32(4)   -- 3.14159
    local stringValue = buffer:GetString(8)   -- "Hello"

    print("Buffer length:", buffer:ByteLength()) -- 64
    print("Values:", intValue, floatValue, stringValue)

    -- Wrap existing binary data
    local existingData = string.pack("i4f", 100, 2.718)
    local wrappedView = Data.DataView.Wrap(existingData)

    -- Read from wrapped data
    local intVal = wrappedView:GetInt32(0)    -- 100
    local floatVal = wrappedView:GetFloat32(4) -- 2.718

    -- Create buffer with mixed data
    local buffer = Data.DataView.ArrayBuffer(32)
    buffer:SetInt32(0, 123)
    buffer:SetFloat32(4, 4.56)
    buffer:SetInt16(8, 789)

    -- Create stream for sequential reading
    local stream = Data.DataView.DataStream.New(buffer)

    -- Read sequentially (offset advances automatically)
    local int1 = stream:Int32()    -- 123, offset now at 4
    local float1 = stream:Float32() -- 4.56, offset now at 8
    local int2 = stream:Int16()    -- 789, offset now at 10

    print("Sequential read:", int1, float1, int2)

    -- Base class
    local Entity = Lib.Class:Create({
        constructor = function(self, id)
            self.id = id
            self.created = os.time()
        end,

        getId = function(self)
            return self.id
        end,

        getInfo = function(self)
            return "Entity " .. self.id
        end
    }, "Entity")

    -- Inherited class
    local Ped = Lib.Class:Create(Entity, "Ped")

    function Ped:constructor(id, model)
        self:super(id) -- Call parent constructor
        self.model = model
    end

    function Ped:getInfo()
        return "Ped " .. self.id .. " (" .. self.model .. ")"
    end

    -- Usage
    local ped = Ped:New(123, "A_M_M_FARMER_01")
    print(ped:getInfo()) -- "Ped 123 (A_M_M_FARMER_01)"
    print(ped:getId())   -- 123 (inherited method)

    local Ped = Lib.Class:Create(Entity, "Ped")
    function Ped:constructor(id, model)
        self:super(id) -- Call parent constructor
        self.model = model
    end

    local Person = Lib.Class:Create({
        constructor = function(self, name, age)
            self.name = name
            self.age = age
        end,
        -- can be used to organize your code as well just like JS classes
        get = {
            name = function(self)
                return self.name:upper() -- Always return uppercase
            end,

            age = function(self)
                return self.age
            end,

            isAdult = function(self)
                return self.age >= 18
            end
        },
        -- can be used to organize your code as well just like JS classes
        set = {
            name = function(self, value)
                if type(value) ~= "string" then
                    error("Name must be a string")
                end
                self.name = value
            end,

            age = function(self, value)
                if type(value) ~= "number" or value < 0 then
                    error("Age must be a positive number")
                end
                self.age = value
            end
        }
    })

    local person = Person:New("john", 25)

    -- Using getters
    print(person.name)    -- "JOHN" (automatic uppercase)
    print(person.isAdult) -- true

    -- Using setters
    person.name = "jane"  -- Validates and stores
    person.age = 30       -- Validates and stores

    local BankAccount = Lib.Class:Create({
        constructor = function(self, accountNumber, initialBalance)
            self._accountNumber = accountNumber  -- Private
            self._balance = initialBalance       -- Private
            self.accountType = "Checking"        -- Public
        end,

        -- Public method that accesses private members
        getBalance = function(self)
            self:_validateAccess() -- Private method call
            return self._balance
        end,

        deposit = function(self, amount)
            if amount > 0 then
                self._balance = self._balance + amount
                return true
            end
            return false
        end,

        -- Private method
        _validateAccess = function(self)
            print("Validating access to account " .. self._accountNumber)
        end,

        -- Private method
        _calculateInterest = function(self)
            return self._balance * 0.01
        end
    }, "BankAccount")

    local account = BankAccount:New("12345", 1000)

    -- ✅ Public access
    print(account:getBalance()) -- 1000
    account:deposit(500)

    -- ❌ Private access will error
    -- print(account._balance)      -- ERROR
    -- account:_validateAccess()    -- ERROR

    local Vehicle = Lib.Class:Create({
        constructor = function(self, model)
            self._engine = "V8"     -- Private to Vehicle
            self.model = model      -- Public
        end,

        getEngineInfo = function(self)
            return "Engine: " .. self._engine -- ✅ Same class access
        end,

        _startEngine = function(self)
            print("Starting " .. self._engine .. " engine")
        end
    })

    local Car = Lib.Class:Create(Vehicle, "Car")

    function Car:constructor(model, doors)
        self:super(model)
        self.doors = doors
        -- self._engine = "Modified"  -- ❌ Would error - can't access parent private
    end

    function Car:tryAccessPrivate()
        -- ❌ Cannot access parent's private members
        -- local engine = self._engine     -- ERROR
        -- self:_startEngine()             -- ERROR
        print("Cannot access parent private members")
    end

    local car = Car:New("Mustang", 2)
    print(car:getEngineInfo()) -- ✅ "Engine: V8" (via public method)
    car:tryAccessPrivate()     -- Shows privacy enforcement