> For the complete documentation index, see [llms.txt](https://inside-scripts.gitbook.io/documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://inside-scripts.gitbook.io/documentation/paid-scripts/notifications-and-progress/functions.md).

# Functions

## <mark style="color:green;">Notify</mark>

{% tabs %}
{% tab title="Client-Side" %}

```lua
exports["is_ui"]:Notify(title, message, duration, style, icon)
```

{% endtab %}

{% tab title="Server-Side" %}

```lua
TriggerClientEvent("is_ui:Notify", playerId, title, message, duration, style, icon)
```

{% endtab %}
{% endtabs %}

* title: `string` or `nil`
* message: `string`
* duration: `number` or `nil`
* style: `string` or `table`
* icon: `string` or `nil`

### Example Usage

{% tabs %}
{% tab title="Client-Side" %}

```lua
-- Example 1: Using Predefined Style
exports["is_ui"]:Notify("Test", "Lorem ipsum <span>adipiscing elit</span>.", 5000, "info")

-- Example 2: Using Predefined Style with Custom Icon
exports["is_ui"]:Notify("Test", "Lorem ipsum adipiscing elit.", 5000, "info", "fa-regular fa-thumbs-up")

-- Example 3: Using Custom Style
local style = {
    icon = "fa-solid fa-sack-dollar",
    primaryColor = "#FF425D",
    backgroundIcon = { from = "#FC3955", to = "#861A20" },
    sound = { play = true, type = "notifySound6", volume = 5 }
}

exports["is_ui"]:Notify("Test", "Lorem adipiscing elit.", 5000, style)
```

{% endtab %}

{% tab title="Server-Side" %}

```lua
-- Example 1: Using Predefined Style
TriggerClientEvent("is_ui:Notify", source, "Test", "Lorem ipsum <span>adipiscing elit</span>.", 5000, "info")

-- Example 2: Using Predefined Style with Custom Icon
TriggerClientEvent("is_ui:Notify", source, "Test", "Lorem ipsum adipiscing elit.", 5000, "info", "fa-regular fa-thumbs-up")

-- Example 3: Using Custom Style
local style = {
    icon = "fa-solid fa-sack-dollar",
    primaryColor = "#FF425D",
    backgroundIcon = { from = "#FC3955", to = "#861A20" },
    sound = { play = true, type = "notifySound6", volume = 5 }
}

TriggerClientEvent("is_ui:Notify", "Test", "Lorem adipiscing elit.", 5000, style)
```

{% endtab %}
{% endtabs %}

### Default Notifications

To quickly change default Notifications, go to the given file and replace the functions to call our export.

**QBCore**

`qb-core` -> `client` -> `functions.lua`

```lua
function QBCore.Functions.Notify(text, style, duration, icon, title)
    local title = title or nil
    local icon = icon or nil

    if style == "primary" then style = "info" end

    exports["is_ui"]:Notify(title, text, tonumber(duration), style, icon)
end
```

**ESX**

`es_extended` -> `client` -> `functions.lua`

```lua
function ESX.ShowNotification(text, style, duration, title, icon)
    exports["is_ui"]:Notify(title or nil, text or "Example Message", tonumber(duration), style or "info", icon or nil)
end
```

**OX Library**

`ox_lib` -> `resource` -> `interface` -> `client` -> `notify.lua`

```lua
function lib.notify(data)
    local title = data.title or nil
    local message = data.description or nil
    local duration = data.duration or nil
    local style = data.type or nil
    local icon = data.icon or nil

    exports["is_ui"]:Notify(title, message, duration, style, icon)
end
```

## <mark style="color:green;">Progress Bar</mark>

The Progress Bar can only be invoked on the Client-Side!

{% tabs %}
{% tab title="Activate" %}

```lua
exports["is_ui"]:ProgressBar(data)
```

{% endtab %}

{% tab title="Cancel" %}

```lua
exports["is_ui"]:cancelProgressBar()
```

{% endtab %}

{% tab title="Is Active" %}

```lua
exports["is_ui"]:IsProgressBarActive()
```

{% endtab %}
{% endtabs %}

* data: `table`
  * title: `string`
  * icon: `string` or `nil`
    * default: `fa-solid fa-user`
  * duration: `number` or `nil`
    * default: `5000`
  * useWhileDead: `boolean` or `nil`
    * default: `false`
  * canCancel: `boolean` or `nil`
    * default: `false`
  * prop: `indexed table` or `nil`
    * hash: `string`
    * bone: `number` or `nil`
      * default: `60309`
    * position: `table`
      * x: `number`
        * default: `0.0`
      * y: `number`
        * default: `0.0`
      * z: `number`
        * default: `0.0`
    * rotation: `table`
      * x: `number`
        * default: `0.0`
      * y: `number`
        * default: `0.0`
      * z: `number`
        * default: `0.0`
  * animation: `table` or `nil`
    * dict: `string`
    * anim: `string`
    * blendIn: `number` or `nil`
      * `default: 3.0`
    * blendOut: `number` or `nil`
      * default: `3.0`
    * duration: `number` or `nil`
      * default: `-1`
    * flag: `number` or `nil`
      * default: `49`
    * playbackRate: `number` or `nil`
      * default: `0`
    * lockX: `boolean` or `nil`
      * default: `false`
    * lockY: `boolean` or `nil`
      * default: `false`
    * lockZ: `boolean` or `nil`
      * default: `false`
  * scenario: `table` or `nil`
    * name: `string`
    * enterAnim: `boolean` or `nil`
      * default: `true`
  * disable: `table` or `nil`
    * move: `boolean` or `nil`
      * default: `false`
    * car: `boolean` or `nil`
      * default: `false`
    * combat: `boolean` or `nil`
      * default: `false`
    * mouse: `boolean` or `nil`
      * default: `false`
    * sprint: `boolean` or `nil`
      * default: `false`

### Example Usage

```lua
-- Example 1: Simple operation

local status = exports["is_ui"]:ProgressBar({
    title = "Test",
    icon = "fa-solid fa-user",
    duration = 5000,
    useWhileDead = false,
    canCancel = false,
    animation = {
        dict = "amb@prop_human_movie_bulb@base",
        anim = "base",
    },
})

if status == true then
    print("done")
elseif status == false then
    print("cancel")
end

-- Example 2: Advanced operation

local status = exports["is_ui"]:ProgressBar({
    title = "Test",
    icon = "fa-solid fa-user",
    duration = 5000,
    useWhileDead = false,
    canCancel = false,
    prop = {
        {
            hash = "bkr_prop_weed_lrg_01b",
            bone = 60309,
            position = {x = 0.0, y = 0.0, z = 0.0},
            rotation = {x = 0.0, y = 0.0, z = 0.0},
        }
    },
    animation = {
        dict = "amb@prop_human_movie_bulb@base",
        anim = "base",
        blendIn = 3.0,
        blendOut = 3.0,
        duration = -1,
        flag = 0,
        playbackRate = 0,
        lockX = false,
        lockY = false,
        lockZ = false
    },
    -- scenario = {
    --     name = "WORLD_HUMAN_PAPARAZZI",
    --     enterAnim = true
    -- },
    disable = {
        move = true,
        car = true,
        combat = true,
        mouse = true,
        sprint = true
    },
})

if status == true then
    print("function done")
elseif status == false then
    print("function cancel")
end
```

### Default Progress Bar

To quickly change default Progress Bar, go to the given file and replace the functions to call our export.

**QBCore**

`qb-core` -> `client` -> `functions.lua`

```lua
function QBCore.Functions.Progressbar(name, label, duration, useWhileDead, canCancel, disableControls, animation, prop, propTwo, onFinish, onCancel, icon)
    if prop and prop.model then
        prop[1] = {
            hash = prop.model,
            bone = prop.bone or nil,
            position = prop.coords or nil,
            rotation = prop.rotation or nil,
        }
    end

    if animation and animation.task then
        local scenario = {
            name = animation.task,
            enterAnim = true
        }
        animation = nil
    elseif animation and animation.animDict and animation.anim then
        animation = {
            dict = animation.animDict,
            anim = animation.anim,
            blendIn = animation.blendIn,
            blendOut = animation.blendOut,
            duration = animation.duration,
            flag = animation.flags,
            playbackRate = animation.playbackRate,
            lockX = animation.lockX,
            lockY = animation.lockY,
            lockZ = animation.lockZ
        }
    end

    if type(disableControls) == "table" then
        local disable = {
            move = disableControls.disableMovement,
            car = disableControls.disableCarMovement,
            combat = disableControls.disableCombat,
            mouse = disableControls.disableMouse,
            sprint = disableControls.disableSprint
        }
    end

    local status = exports["is_ui"]:ProgressBar({
        title = label,
        icon = icon,
        duration = duration,
        useWhileDead = useWhileDead,
        canCancel = canCancel,
        prop = prop,
        animation = animation,
        scenario = scenario,
        disable = disable
    })

    if status == true then  
        if onFinish then
            onFinish()
        end
    elseif status == false then
        if onCancel then
            onCancel()
        end
    end
end
```

**ESX**

`es_extended` -> `client` -> `functions.lua`

```lua
function ESX.Progressbar(title, duration, Options)
    if Options.prop and Options.prop.hash then
        prop[1] = {
            hash = Options.prop.hash,
            bone = Options.prop.bone or nil,
            position = Options.prop.position or nil,
            rotation = Options.prop.rotation or nil,
        }
    end

    if Options.animation and Options.animation.type == "Scenario" then
        local scenario = {
            name = Options.animation.Scenario,
            enterAnim = Options.animation.enterAnim
        }
    elseif Options.animation and Options.animation.type == "anim" then
        local animation = {
            dict = Options.animation.dict,
            anim = Options.animation.lib,
            blendIn = Options.animation.blendIn,
            blendOut = Options.animation.blendOut,
            duration = Options.animation.duration,
            flag = Options.animation.flag,
            playbackRate = Options.animation.playbackRate,
            lockX = Options.animation.lockX,
            lockY = Options.animation.lockY,
            lockZ = Options.animation.lockZ
        }
    end

    if Options.disable and type(Options.disable) == "table" then
        local disable = Options.disable
    end

    local status = exports["is_ui"]:ProgressBar({
        title = title,
        icon = Options.icon,
        duration = duration,
        useWhileDead = Options.useWhileDead,
        canCancel = Options.canCancel,
        prop = prop,
        animation = animation,
        scenario = scenario,
        disable = disable
    })

    if status == true then  
        if Options.onFinish then
            Options.onFinish()
        end
    elseif status == false then
        if Options.onCancel then
            Options.onCancel()
        end
    end
end
```

**OX Library**

`ox_lib` -> `resource` -> `interface` -> `client` -> `progress.lua`

```lua
function lib.progressBar(data)
    local prop, animation, scenario

    if data.prop and data.prop[1] then
        prop = {}

        for _, v in ipairs(data.prop) do
            table.insert(prop, {
                hash = v.model,
                bone = v.bone,
                position = v.pos and {
                    x = v.pos.x,
                    y = v.pos.y,
                    z = v.pos.z,
                } or {},
                rotation = v.rot and {
                    x = v.rot.x,
                    y = v.rot.y,
                    z = v.rot.z,
                } or {},
            })
        end
    elseif data.prop and data.prop.model then
        prop = {}

        prop[1] = {
            hash = data.prop.model,
            bone = data.prop.bone,
            position = data.prop.pos and {
                x = data.prop.pos.x,
                y = data.prop.pos.y,
                z = data.prop.pos.z,
            } or {},
            rotation = data.prop.rot and {
                x = data.prop.rot.x,
                y = data.prop.rot.y,
                z = data.prop.rot.z,
            } or {},
        }
    end

    if data.anim and data.anim.dict and data.anim.clip then
        animation = {
            dict = data.anim.dict,
            anim = data.anim.clip,
            blendIn = data.anim.blendIn,
            blendOut = data.anim.blendOut,
            duration = data.anim.duration,
            flag = data.anim.flag,
            playbackRate = data.anim.playbackRate,
            lockX = data.anim.lockX,
            lockY = data.anim.lockY,
            lockZ = data.anim.lockZ,
        }
    elseif data.anim and data.scenario then
        scenario = {
            name = data.anim.scenario,
            enterAnim = data.anim.playEnter,
        }
    end

    local data = {
        title = data.label,
        icon = data.icon,
        duration = data.duration,
        useWhileDead = data.useWhileDead,
        canCancel = data.canCancel,
        prop = prop,
        animation = animation,
        scenario = scenario,
        disable = data.disable,
    }

    return exports["is_ui"]:ProgressBar(data)
end

function lib.progressCircle(data)
    return lib.progressBar(data)
end

function lib.cancelProgress()
    exports["is_ui"]:cancelProgressBar()
end

function lib.progressActive()
    return exports["is_ui"]:IsProgressBarActive()
end
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://inside-scripts.gitbook.io/documentation/paid-scripts/notifications-and-progress/functions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.