### Install WindUI using Luau Script

Source: https://github.com/footagesus/windui/blob/main/README.md

This code snippet demonstrates how to install and run the WindUI framework using a Luau script. It fetches the script from a GitHub URL and executes it locally. This method is suitable for environments that support Luau scripting.

```luau
loadstring(game:HttpGet('https://raw.githubusercontent.com/Footagesus/WindUI/refs/heads/main/main_example.lua'))()
```

--------------------------------

### Creating a Window

Source: https://context7.com/footagesus/windui/llms.txt

Provides an example of how to create the main application window using WindUI, including configurations for title, author, icon, size, theme, search bar, and open button.

```APIDOC
## Creating a Window

### Description
Create the main window interface with customizable settings and visual appearance.

### Method
`CreateWindow`

### Endpoint
N/A

### Parameters
#### Request Body
- **Title** (string) - Required - The title of the window.
- **Author** (string) - Required - The author of the application.
- **Folder** (string) - Required - The name of the configuration folder.
- **Icon** (string) - Optional - The icon for the window (e.g., Lucide icon name).
- **IconSize** (number) - Optional - The size of the icon.
- **Size** (UDim2) - Required - The size of the window.
- **Theme** (string) - Optional - The theme of the window ('Dark' or 'Light').
- **HideSearchBar** (boolean) - Optional - Whether to hide the search bar.
- **OpenButton** (table) - Optional - Configuration for the open button.
  - **Title** (string) - Required - The title of the open button.
  - **CornerRadius** (UDim) - Optional - The corner radius of the button.
  - **StrokeThickness** (number) - Optional - The stroke thickness of the button.
  - **Enabled** (boolean) - Optional - Whether the button is enabled.
  - **Draggable** (boolean) - Optional - Whether the button is draggable.
  - **OnlyMobile** (boolean) - Optional - Whether the button is only for mobile.
  - **Scale** (number) - Optional - The scale of the button.
  - **Color** (ColorSequence) - Optional - The color sequence of the button.
- **Topbar** (table) - Optional - Configuration for the top bar.
  - **Height** (number) - Required - The height of the top bar.
  - **ButtonsType** (string) - Optional - The type of buttons in the top bar ('Default' or 'Mac').

### Request Example
```lua
local WindUI = loadstring(game:HttpGet("https://raw.githubusercontent.com/Footagesus/WindUI/main/dist/main.lua"))()

local Window = WindUI:CreateWindow({
    Title = ".ftgs hub | WindUI Example",
    Author = "by .ftgs • Footagesus",
    Folder = "ftgshub", -- Config folder name
    Icon = "solar:folder-2-bold-duotone",
    IconSize = 22*2,
    Size = UDim2.fromOffset(700, 700),
    Theme = "Dark", -- or "Light"

    -- Search bar configuration
    HideSearchBar = false,

    -- Open button configuration
    OpenButton = {
        Title = "Open .ftgs hub UI",
        CornerRadius = UDim.new(1, 0), -- Fully rounded
        StrokeThickness = 3,
        Enabled = true,
        Draggable = true,
        OnlyMobile = false,
        Scale = 0.5,
        Color = ColorSequence.new(
            Color3.fromHex("#30FF6A"),
            Color3.fromHex("#e7ff2f")
        )
    },

    -- Top bar configuration
    Topbar = {
        Height = 44,
        ButtonsType = "Mac", -- "Default" or "Mac"
    },
})
```

### Response
#### Success Response (200)
Returns the created Window object.

#### Response Example
N/A
```

--------------------------------

### Create Gradient Utility - Lua

Source: https://context7.com/footagesus/windui/llms.txt

Shows how to create a gradient object with defined color stops and transparency levels. The example also demonstrates applying this gradient to a Roblox Frame instance using a UIGradient object.

```lua
local myGradient = WindUI:Gradient({
    [0] = {
        Color = Color3.fromHex("#30FF6A"),
        Transparency = 0,
    },
    [50] = {
        Color = Color3.fromHex("#e7ff2f"),
        Transparency = 0,
    },
    [100] = {
        Color = Color3.fromHex("#ff4830"),
        Transparency = 0,
    }
}, {
    Rotation = 45, -- Gradient angle
})

-- Apply gradient to Frame
local frame = Instance.new("Frame")
local gradient = Instance.new("UIGradient", frame)
gradient.Color = myGradient.Color
gradient.Transparency = myGradient.Transparency
gradient.Rotation = myGradient.Rotation
```

--------------------------------

### Creating a Main Window

Source: https://context7.com/footagesus/windui/llms.txt

Shows how to create the primary window for the WindUI interface. This includes setting the title, author, configuration folder, icon, size, theme, and configuring search bar and open button properties.

```lua
local WindUI = loadstring(game:HttpGet("https://raw.githubusercontent.com/Footagesus/WindUI/main/dist/main.lua"))()

local Window = WindUI:CreateWindow({
    Title = ".ftgs hub | WindUI Example",
    Author = "by .ftgs • Footagesus",
    Folder = "ftgshub", -- Config folder name
    Icon = "solar:folder-2-bold-duotone",
    IconSize = 22*2,
    Size = UDim2.fromOffset(700, 700),
    Theme = "Dark", -- or "Light"

    -- Search bar configuration
    HideSearchBar = false,

    -- Open button configuration
    OpenButton = {
        Title = "Open .ftgs hub UI",
        CornerRadius = UDim.new(1, 0), -- Fully rounded
        StrokeThickness = 3,
        Enabled = true,
        Draggable = true,
        OnlyMobile = false,
        Scale = 0.5,
        Color = ColorSequence.new(
            Color3.fromHex("#30FF6A"),
            Color3.fromHex("#e7ff2f")
        )
    },

    -- Top bar configuration
    Topbar = {
        Height = 44,
        ButtonsType = "Mac", -- "Default" or "Mac"
    },
})
```

--------------------------------

### Create Protected Window with Key System - Lua

Source: https://context7.com/footagesus/windui/llms.txt

Demonstrates how to create a new window with an integrated key system for authentication. Supports single keys, multiple keys, saving keys, and custom validation functions. Optionally includes API integration for services like Luarmor or Pelican.

```lua
local Window = WindUI:CreateWindow({
    Title = "Protected Hub",
    Folder = "protectedhub",

    KeySystem = {
        Key = "mykey123", -- Simple key
        -- Or multiple keys: Key = {"key1", "key2", "key3"},
        SaveKey = true, -- Remember validated keys

        -- Custom key validator
        KeyValidator = function(key)
            return key == "mykey123" or key == "secretkey"
        end,

        -- API integration (e.g., Luarmor, Pelican)
        API = {
            {
                Type = "Luarmor",
                Script = "your-script-id",
            }
        }
    }
})
```

--------------------------------

### Manage Configuration with WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Explains how to manage user settings and configurations persistently across sessions. This includes defining savable UI elements using 'Flag', saving, loading, and deleting configurations, as well as retrieving all available configuration names.

```lua
-- Get config manager from window
local ConfigManager = Window.ConfigManager

-- Define elements with Flag parameter to save them
SettingsTab:Toggle({
    Flag = "AutoSave",
    Title = "Auto Save",
    Value = true,
    Callback = function(state)
        print("Auto save:", state)
    end
})

SettingsTab:Slider({
    Flag = "Volume",
    Title = "Volume",
    Value = {Min = 0, Max = 100, Default = 50},
    Callback = function(value)
        print("Volume:", value)
    end
})

-- Save config
local ConfigName = "myconfig"
Window.CurrentConfig = ConfigManager:Config(ConfigName)
if Window.CurrentConfig:Save() then
    WindUI:Notify({
        Title = "Config Saved",
        Content = "Configuration saved successfully!",
        Icon = "check",
    })
end

-- Load config
Window.CurrentConfig = ConfigManager:CreateConfig(ConfigName)
if Window.CurrentConfig:Load() then
    WindUI:Notify({
        Title = "Config Loaded",
        Content = "Configuration loaded successfully!",
        Icon = "refresh-cw",
    })
end

-- Get all configs
local AllConfigs = ConfigManager:AllConfigs()
print("Available configs:", table.concat(AllConfigs, ", "))

-- Delete config
ConfigManager:DeleteConfig(ConfigName)
```

--------------------------------

### Loading WindUI Library

Source: https://context7.com/footagesus/windui/llms.txt

Demonstrates how to load the WindUI library into your Roblox script environment. It includes methods for loading directly from GitHub via `game:HttpGet` and from `ReplicatedStorage` within Roblox Studio.

```lua
-- Load WindUI from GitHub
local WindUI = loadstring(game:HttpGet("https://raw.githubusercontent.com/Footagesus/WindUI/main/dist/main.lua"))()

-- Alternative: Load from ReplicatedStorage in Roblox Studio
local WindUI = require(game:GetService("ReplicatedStorage"):WaitForChild("WindUI"):WaitForChild("Init"))
```

--------------------------------

### Loading WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Demonstrates two methods for loading the WindUI library into your Roblox script environment: directly from GitHub via `loadstring` or by requiring it from ReplicatedStorage.

```APIDOC
## Loading WindUI

### Description
Load the WindUI library into your Roblox script environment.

### Method
`loadstring` or `require`

### Endpoint
N/A

### Parameters
None

### Request Example
```lua
-- Load WindUI from GitHub
local WindUI = loadstring(game:HttpGet("https://raw.githubusercontent.com/Footagesus/WindUI/main/dist/main.lua"))()

-- Alternative: Load from ReplicatedStorage in Roblox Studio
local WindUI = require(game:GetService("ReplicatedStorage"):WaitForChild("WindUI"):WaitForChild("Init"))
```

### Response
#### Success Response (200)
Returns the WindUI library object.

#### Response Example
N/A
```

--------------------------------

### Creating Navigation Tabs

Source: https://context7.com/footagesus/windui/llms.txt

Illustrates how to create distinct tabs within the main WindUI window to organize content. Each tab can have a title, description, icon, and customizable icon shape and border.

```lua
local AboutTab = Window:Tab({
    Title = "About WindUI",
    Desc = "Description Example",
    Icon = "solar:info-square-bold",
    IconColor = Color3.fromHex("#83889E"),
    IconShape = "Square", -- "Square" or "Circle"
    Border = true,
})

local SettingsTab = Window:Tab({
    Title = "Settings",
    Icon = "solar:settings-bold",
    IconColor = Color3.fromHex("#7775F2"),
    IconShape = "Circle",
    Border = false,
})
```

--------------------------------

### Create Modal Popups with WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Illustrates the creation of modal popup windows for user interaction and confirmation. Popups can feature titles, icons, content, and multiple buttons, each with customizable text, icons, variants, and callback functions for specific actions.

```lua
local MyPopup = WindUI:Popup({
    Title = "Welcome to WindUI!",
    Icon = "bird",
    Content = "This is a popup message with multiple buttons.",
    Buttons = {
        {
            Title = "Accept",
            Icon = "check",
            Variant = "Primary", -- "Primary", "Secondary", or "Tertiary"
            Callback = function()
                print("Accept clicked")
            end
        },
        {
            Title = "Decline",
            Icon = "x",
            Variant = "Tertiary",
            Callback = function()
                print("Decline clicked")
            end
        },
        {
            Title = "More Info",
            Icon = "info",
            Variant = "Secondary",
            Callback = function()
                print("More Info clicked")
            end
        }
    }
})
```

--------------------------------

### Customize Themes with WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Details how to manage the application's visual theme. This includes setting predefined themes (Dark/Light), retrieving the current theme, listing all available themes, adding custom themes with specific color definitions, and listening for theme change events.

```lua
-- Set theme
WindUI:SetTheme("Dark") -- "Dark" or "Light"
WindUI:SetTheme("Light")

-- Get current theme
local currentTheme = WindUI:GetCurrentTheme()
print("Current theme:", currentTheme)

-- Get all available themes
local allThemes = WindUI:GetThemes()
for themeName, themeData in pairs(allThemes) do
    print("Theme:", themeName)
end

-- Add custom theme
WindUI:AddTheme({
    Name = "Custom",
    Primary = Color3.fromHex("#30FF6A"),
    Secondary = Color3.fromHex("#e7ff2f"),
    Background = Color3.fromHex("#1c1c1c"),
    -- ... other color definitions
})

-- Listen for theme changes
WindUI:OnThemeChange(function(themeName)
    print("Theme changed to:", themeName)
end)
```

--------------------------------

### Creating Content Sections

Source: https://context7.com/footagesus/windui/llms.txt

Demonstrates how to group related UI elements within tabs using sections. Sections can be titled, described, visually boxed, and have adjustable text size and font weight. They can be created within a tab or directly from the window.

```lua
local MainSection = AboutTab:Section({
    Title = "Main Settings",
    Desc = "Configure primary options",
    Box = true, -- Wrap in a box
    BoxBorder = true, -- Show border on box
    Opened = true, -- Initially expanded
    TextSize = 18,
    FontWeight = Enum.FontWeight.SemiBold,
})

-- Sections can also be created from Window
local ElementsSection = Window:Section({
    Title = "Elements",
})
```

--------------------------------

### Creating Tabs

Source: https://context7.com/footagesus/windui/llms.txt

Explains how to create navigation tabs within a WindUI window, allowing for organization of UI elements. Each tab can have a title, description, icon, and border.

```APIDOC
## Creating Tabs

### Description
Organize UI elements into navigational tabs with icons and descriptions.

### Method
`Tab`

### Endpoint
N/A

### Parameters
#### Request Body
- **Title** (string) - Required - The title of the tab.
- **Desc** (string) - Optional - A description for the tab.
- **Icon** (string) - Optional - The icon for the tab (e.g., Lucide icon name).
- **IconColor** (Color3) - Optional - The color of the tab icon.
- **IconShape** (string) - Optional - The shape of the tab icon ('Square' or 'Circle').
- **Border** (boolean) - Optional - Whether the tab has a border.

### Request Example
```lua
local AboutTab = Window:Tab({
    Title = "About WindUI",
    Desc = "Description Example",
    Icon = "solar:info-square-bold",
    IconColor = Color3.fromHex("#83889E"),
    IconShape = "Square", -- "Square" or "Circle"
    Border = true,
})

local SettingsTab = Window:Tab({
    Title = "Settings",
    Icon = "solar:settings-bold",
    IconColor = Color3.fromHex("#7775F2"),
    IconShape = "Circle",
    Border = false,
})
```

### Response
#### Success Response (200)
Returns the created Tab object.

#### Response Example
N/A
```

--------------------------------

### Add Tags to Window Header with WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Shows how to add informational tags to the window's header. Tags can display text, icons, and have customizable colors and borders, useful for indicating version, status (e.g., BETA), or other metadata.

```lua
Window:Tag({
    Title = "v" .. WindUI.Version,
    Icon = "github",
    Color = Color3.fromHex("#1c1c1c"),
    Border = true,
})

Window:Tag({
    Title = "BETA",
    Icon = "alert-circle",
    Color = Color3.fromHex("#ECA201"),
    Border = false,
})
```

--------------------------------

### Creating Toggle/Checkbox Elements

Source: https://context7.com/footagesus/windui/llms.txt

Demonstrates how to create toggle switches or checkboxes for managing boolean states. These elements can be configured with titles, descriptions, default values, and a callback function that is triggered when the state changes. They also support programmatic state setting and locking.

```lua
local MyToggle = SettingsTab:Toggle({
    Title = "Enable Feature",
    Desc = "Toggle this feature on/off",
    Type = "Toggle", -- "Toggle" or "Checkbox"
    Value = false, -- Default state
    Flag = "FeatureToggle", -- Save to config
    Locked = false,
    LockedTitle = "This element is locked",
    Callback = function(state)
        print("Toggle state:", state)
        if state then
            print("Feature enabled")
        else
            print("Feature disabled")
        end
    end
})

-- Programmatically set toggle state
MyToggle:Set(true)
```

--------------------------------

### Creating Sections

Source: https://context7.com/footagesus/windui/llms.txt

Details how to create sections within tabs or directly from the window to group related UI elements. Sections can be boxed, have borders, and be initially expanded.

```APIDOC
## Creating Sections

### Description
Group related elements within tabs using sections.

### Method
`Section`

### Endpoint
N/A

### Parameters
#### Request Body
- **Title** (string) - Required - The title of the section.
- **Desc** (string) - Optional - A description for the section.
- **Box** (boolean) - Optional - Whether to wrap the section in a box.
- **BoxBorder** (boolean) - Optional - Whether to show a border on the section box.
- **Opened** (boolean) - Optional - Whether the section is initially expanded.
- **TextSize** (number) - Optional - The text size for the section title.
- **FontWeight** (Enum.FontWeight) - Optional - The font weight for the section title.

### Request Example
```lua
local MainSection = AboutTab:Section({
    Title = "Main Settings",
    Desc = "Configure primary options",
    Box = true, -- Wrap in a box
    BoxBorder = true, -- Show border on box
    Opened = true, -- Initially expanded
    TextSize = 18,
    FontWeight = Enum.FontWeight.SemiBold,
})

-- Sections can also be created from Window
local ElementsSection = Window:Section({
    Title = "Elements",
})
```

### Response
#### Success Response (200)
Returns the created Section object.

#### Response Example
N/A
```

--------------------------------

### Creating Button Elements

Source: https://context7.com/footagesus/windui/llms.txt

Shows how to create interactive buttons within a WindUI tab or section. Buttons can have titles, descriptions, icons, specific alignment and justification, colors, and a callback function that executes when clicked. They can also be highlighted for emphasis.

```lua
local MyButton = AboutTab:Button({
    Title = "Click Me",
    Desc = "Button description",
    Icon = "mouse",
    IconAlign = "Left", -- "Left" or "Right"
    Justify = "Center", -- "Left", "Center", or "Right"
    Color = Color3.fromHex("#305dff"),
    Locked = false,
    LockedTitle = "This element is locked",
    Callback = function()
        print("Button clicked!")
        WindUI:Notify({
            Title = "Success",
            Content = "Button was clicked!",
            Icon = "check",
            Duration = 3,
        })
    end
})

-- Highlight a button to draw attention
MyButton:Highlight()
```

--------------------------------

### Display Images with Aspect Ratio Control in WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Demonstrates how to display images fetched from URLs. The component allows for specifying the image source, controlling the aspect ratio (e.g., 16:9, 4:3, 1:1), and setting corner radius for rounded edges.

```lua
AboutTab:Image({
    Image = "https://repository-images.githubusercontent.com/880118829/22c020eb-d1b1-4b34-ac4d-e33fd88db38d",
    AspectRatio = "16:9", -- "16:9", "4:3", "1:1", etc.
    Radius = 9, -- Corner radius
})
```

--------------------------------

### Create and Control Dropdowns (Lua)

Source: https://context7.com/footagesus/windui/llms.txt

Implements dropdown menus for selecting options from a list. Supports simple lists, advanced options with icons and descriptions, single or multi-select modes, and allowing deselection. Dropdown values can be refreshed or set programmatically.

```lua
-- Simple dropdown
local SimpleDropdown = SettingsTab:Dropdown({
    Title = "Select Language",
    Desc = "Choose your language",
    Values = {"English", "Spanish", "French", "German"},
    Value = "English", -- Default selection (1-indexed or value)
    Multi = false, -- Single selection
    AllowNone = true, -- Allow deselection
    Flag = "LanguageDropdown",
    Callback = function(selectedValue)
        print("Selected:", selectedValue)
    end
})

-- Advanced dropdown with icons and descriptions
local AdvancedDropdown = SettingsTab:Dropdown({
    Title = "File Actions",
    Values = {
        {
            Title = "New file",
            Desc = "Create a new file",
            Icon = "file-plus",
            Callback = function()
                print("Creating new file")
            end
        },
        {
            Title = "Copy link",
            Desc = "Copy the file link",
            Icon = "copy",
            Callback = function()
                print("Copying link")
            end
        },
        {
            Type = "Divider", -- Visual separator
        },
        {
            Title = "Delete file",
            Desc = "Permanently delete the file",
            Icon = "trash",
            Callback = function()
                print("Deleting file")
            end
        },
    }
})

-- Multi-select dropdown
local MultiDropdown = SettingsTab:Dropdown({
    Title = "Select Features",
    Values = {"Feature A", "Feature B", "Feature C"},
    Multi = true,
    Callback = function(selectedValue)
        print("Selected:", selectedValue)
    end
})

-- Programmatically refresh dropdown values
SimpleDropdown:Refresh({"English", "Spanish", "French", "German", "Japanese"})

-- Programmatically set dropdown value
SimpleDropdown:Set("Spanish")
```

--------------------------------

### Toggle Element

Source: https://context7.com/footagesus/windui/llms.txt

Explains the creation and usage of toggle switches or checkboxes in WindUI. This includes setting the default state, a flag for saving to configuration, and a callback function to handle state changes.

```APIDOC
## Toggle Element

### Description
Create toggle switches or checkboxes with state management.

### Method
`Toggle`

### Endpoint
N/A

### Parameters
#### Request Body
- **Title** (string) - Required - The title of the toggle.
- **Desc** (string) - Optional - A description for the toggle.
- **Type** (string) - Optional - The type of element ('Toggle' or 'Checkbox').
- **Value** (boolean) - Required - The default state of the toggle.
- **Flag** (string) - Optional - A flag name to save the state to configuration.
- **Locked** (boolean) - Optional - Whether the toggle is locked.
- **LockedTitle** (string) - Optional - The title displayed when the toggle is locked.
- **Callback** (function) - Optional - Function to execute when the toggle state changes. Receives the new state as an argument.

### Request Example
```lua
local MyToggle = SettingsTab:Toggle({
    Title = "Enable Feature",
    Desc = "Toggle this feature on/off",
    Type = "Toggle", -- "Toggle" or "Checkbox"
    Value = false, -- Default state
    Flag = "FeatureToggle", -- Save to config
    Locked = false,
    LockedTitle = "This element is locked",
    Callback = function(state)
        print("Toggle state:", state)
        if state then
            print("Feature enabled")
        else
            print("Feature disabled")
        end
    end
})

-- Programmatically set toggle state
MyToggle:Set(true)
```

### Response
#### Success Response (200)
Returns the created Toggle object.

#### Response Example
N/A
```

--------------------------------

### Button Element

Source: https://context7.com/footagesus/windui/llms.txt

Shows how to create interactive buttons within WindUI. Buttons can have titles, descriptions, icons, custom colors, and an optional callback function for click events. They also support highlighting.

```APIDOC
## Button Element

### Description
Create clickable buttons with icons, colors, and callback functions.

### Method
`Button`

### Endpoint
N/A

### Parameters
#### Request Body
- **Title** (string) - Required - The text displayed on the button.
- **Desc** (string) - Optional - A description for the button.
- **Icon** (string) - Optional - The icon to display on the button (e.g., 'mouse').
- **IconAlign** (string) - Optional - Alignment of the icon ('Left' or 'Right').
- **Justify** (string) - Optional - Justification of the button text ('Left', 'Center', or 'Right').
- **Color** (Color3) - Optional - The background color of the button.
- **Locked** (boolean) - Optional - Whether the button is locked.
- **LockedTitle** (string) - Optional - The title displayed when the button is locked.
- **Callback** (function) - Optional - Function to execute when the button is clicked.

### Request Example
```lua
local MyButton = AboutTab:Button({
    Title = "Click Me",
    Desc = "Button description",
    Icon = "mouse",
    IconAlign = "Left", -- "Left" or "Right"
    Justify = "Center", -- "Left", "Center", or "Right"
    Color = Color3.fromHex("#305dff"),
    Locked = false,
    LockedTitle = "This element is locked",
    Callback = function()
        print("Button clicked!")
        WindUI:Notify({
            Title = "Success",
            Content = "Button was clicked!",
            Icon = "check",
            Duration = 3,
        })
    end
})

-- Highlight a button to draw attention
MyButton:Highlight()
```

### Response
#### Success Response (200)
Returns the created Button object.

#### Response Example
N/A
```

--------------------------------

### Control Window Behavior and Appearance with WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Provides methods for dynamically controlling the window's behavior and appearance. This includes destroying the window, setting UI scale, toggling panel background visibility, enabling/disabling acrylic blur effects, and setting the parent container.

```lua
-- Destroy window
Window:Destroy()

-- Set UI scale
Window:SetUIScale(0.8) -- 80% scale

-- Set panel background visibility
Window:SetPanelBackground(true) -- Show
Window:SetPanelBackground(false) -- Hide

-- Toggle acrylic effect (blur background)
WindUI:ToggleAcrylic(true) -- Enable
WindUI:ToggleAcrylic(false) -- Disable

-- Set parent container
WindUI:SetParent(game.Players.LocalPlayer.PlayerGui)
```

--------------------------------

### Display Notifications with WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Demonstrates how to display temporary notification messages to the user. Notifications can include titles, content, icons, and adjustable durations. Basic and advanced configurations are shown, including how to display error messages and add a close button.

```lua
-- Basic notification
WindUI:Notify({
    Title = "Welcome",
    Content = "Welcome to WindUI!",
    Duration = 5, -- Seconds
})

-- Advanced notification with icon
WindUI:Notify({
    Title = "Success",
    Content = "Operation completed successfully!",
    Icon = "solar:bell-bold",
    Duration = 3,
    CanClose = true, -- Show close button
})

-- Error notification
WindUI:Notify({
    Title = "Error",
    Content = "Something went wrong!",
    Icon = "alert-circle",
    Duration = 5,
})
```

--------------------------------

### Create and Control Colorpickers (Lua)

Source: https://context7.com/footagesus/windui/llms.txt

Generates color picker elements with controls for RGB values and transparency. Supports setting default colors and handling color and transparency changes via callbacks. Colors can be set programmatically using RGB or hex codes.

```lua
local MyColorpicker = SettingsTab:Colorpicker({
    Title = "Background Color",
    Desc = "Choose background color",
    Default = Color3.fromRGB(0, 255, 0),
    Transparency = 0, -- 0 to 1
    Flag = "BackgroundColor",
    Locked = false,
    Callback = function(color, transparency)
        print("Selected color:", color)
        print("Transparency:", transparency)
        workspace.Baseplate.Color = color
        workspace.Baseplate.Transparency = transparency
    end
})

-- Programmatically set color
MyColorpicker:Set(Color3.fromHex("#ff4830"))
```

--------------------------------

### Create and Control Input Fields (Lua)

Source: https://context7.com/footagesus/windui/llms.txt

Generates single-line text input fields and multi-line text areas. Supports setting placeholder text, default values, and callbacks for input changes. Values can also be set programmatically.

```lua
local MyInput = SettingsTab:Input({
    Title = "Username",
    Desc = "Enter your username",
    Icon = "user",
    Type = "Input", -- "Input" or "Textarea"
    Placeholder = "Enter text here...",
    Value = "", -- Default value
    Flag = "UsernameInput",
    Locked = false,
    Callback = function(value)
        print("Input value:", value)
    end
})

-- Textarea for multi-line input
local MyTextarea = SettingsTab:Input({
    Title = "Script Code",
    Type = "Textarea",
    Placeholder = "Enter script code...",
    Callback = function(value)
        print("Script:", value)
    end
})

-- Programmatically set input value
MyInput:Set("NewUsername")
```

--------------------------------

### Create and Control Sliders (Lua)

Source: https://context7.com/footagesus/windui/llms.txt

Creates draggable sliders for numeric value selection. Features include optional tooltips, textboxes to display the value, configurable step increments, and min/max ranges. Values can be set programmatically.

```lua
local MySlider = SettingsTab:Slider({
    Title = "Speed Multiplier",
    Desc = "Adjust character speed",
    Width = 200,
    Step = 1, -- Increment step
    IsTooltip = true, -- Show value tooltip
    IsTextbox = true, -- Show value textbox
    Flag = "SpeedSlider",
    Value = {
        Min = 0,
        Max = 200,
        Default = 100,
    },
    Icons = {
        From = "sfsymbols:sunMinFill", -- Left icon
        To = "sfsymbols:sunMaxFill", -- Right icon
    },
    Callback = function(value)
        print("Slider value:", value)
        game.Players.LocalPlayer.Character.Humanoid.WalkSpeed = value
    end
})

-- Programmatically set slider value
MySlider:Set(150)
```

--------------------------------

### Create and Control Group Elements (Lua)

Source: https://context7.com/footagesus/windui/llms.txt

Organizes multiple UI elements within a visual container. Allows adding various elements like buttons, toggles, and color pickers inside the group, along with spacing. Elements within the group can be configured independently.

```lua
local MyGroup = SettingsTab:Group({})

MyGroup:Button({
    Title = "Button 1",
    Justify = "Center",
    Icon = "",
    Callback = function()
        print("Button 1 clicked")
    end
})

MyGroup:Space() -- Add spacing between elements

MyGroup:Toggle({
    Title = "Toggle 1",
    Callback = function(value)
        print("Toggle 1:", value)
    end
})

MyGroup:Space()

MyGroup:Colorpicker({
    Title = "Color 1",
    Default = Color3.fromHex("#30ff6a"),
    Callback = function(color)
        print("Color:", color)
    end
})
```

--------------------------------

### Add and Use Custom Icons - Lua

Source: https://context7.com/footagesus/windui/llms.txt

Explains how to add custom icon sets to WindUI and then utilize these icons in UI elements like buttons. Icons are defined with a name and an asset ID, and can be referenced by a prefixed name (e.g., 'solar:CheckSquareBold').

```lua
WindUI.Creator.AddIcons("solar", {
    ["CheckSquareBold"] = "rbxassetid://132438947521974",
    ["CursorSquareBold"] = "rbxassetid://120306472146156",
    ["FileTextBold"] = "rbxassetid://89294979831077",
    ["FolderWithFilesBold"] = "rbxassetid://74631950400584",
    ["HamburgerMenuBold"] = "rbxassetid://134384554225463",
    ["Home2Bold"] = "rbxassetid://92190299966310",
})

-- Use custom icons
MyTab:Button({
    Title = "Custom Icon Button",
    Icon = "solar:CheckSquareBold",
    Callback = function()
        print("Button with custom icon clicked")
    end
})
```

--------------------------------

### Add Spacing Elements in WindUI

Source: https://context7.com/footagesus/windui/llms.txt

Explains how to insert visual spacing between UI elements. This can be done with default spacing or custom spacing defined in column units, allowing for precise control over element layout and visual separation.

```lua
-- Default spacing
SettingsTab:Space()

-- Custom spacing with column units
SettingsTab:Space({ Columns = 3 }) -- 3x default spacing
SettingsTab:Space({ Columns = 1 }) -- 1x default spacing
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.