Open Ticket v4.0.3

Open Ticket v4.0.3

.docs/createDocs.js

@@ -0,0 +1,328 @@
+//@ts-check
+const fs = require("fs")
+
+/*////// OT DOCS GENERATOR ////////
+What does this file do?:
+Well, this file will parse the result returned from typedoc (the documentation generator).
+The resulting file will then be used in the OT Docs markdown generator to generate the Open Ticket API Reference.
+
+In short:
+This file generates the documentation for Open Ticket :)
+
+Contributing:
+If you want to contribute to the Open Ticket Docs, please run the following command:
+
+> npm run docs
+
+This will give you a "result.json" file which can then be used in the OT Docs.
+Further instructions can be found there.
+/////////////////////////////////*/
+
+if (!fs.existsSync(".docs/typedoc-result.json")){
+    console.log("Unable to generate documentation! Run typedoc first!")
+    process.exit(1)
+}
+const result = JSON.parse(fs.readFileSync(".docs/typedoc-result.json").toString())
+const availableElements = []
+const skipElementNames = [
+    "#opendiscord-types"
+]
+
+const handleFunction = (memberType) => {
+    if (!memberType || !memberType.signatures || !Array.isArray(memberType.signatures)) return {type:"unknown"}
+    
+    //try to get signature
+    let signature = memberType.signatures.find((s) => !s.typeParameters)
+    if (!signature) signature = memberType.signatures[0]
+    if (!signature) return {type:"unknown"}
+
+    //try to get comment
+    let comment = signature.comment
+    if (!comment) comment = memberType.signatures.find((s) => s.comment)?.comment
+    if (!comment) comment = null
+
+    const signatureInherited = signature.flags.isInherited ? true : false
+    const signatureComment = comment ? comment.summary?.map((c) => c.text).join("") : null
+    const signatureParameters = signature.parameters?.map((p) => {
+        return {name:p.name,details:handleType(p.type)}
+    }) ?? []
+    const signatureReturns = handleType(signature.type)
+
+    return {type:"function",inherited:signatureInherited,comment:signatureComment,parameters:signatureParameters,returns:signatureReturns}
+}
+
+const handleObject = (memberType) => {
+    if (!memberType || !memberType.children || !Array.isArray(memberType.children)) return {type:"unknown"}
+    const propertyIds = memberType.groups?.find((g) => g.title == "Properties")?.children ?? []
+    const methodIds = memberType.groups?.find((g) => g.title == "Methods")?.children ?? []
+
+    const objectChildren = []
+    for (const member of (memberType.children ?? [])){
+        const memberName = member.name
+        const memberType = propertyIds.includes(member.id) ? "property" : methodIds.includes(member.id) ? "method" : "other"
+        let memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+        
+        const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+        let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+        let memberDetails = null
+        if (memberType == "property"){
+            //INTERFACE => PROPERTY
+            memberDetails = handleType(member.type)
+        }else if (memberType == "method"){
+            //INTERFACE => METHOD
+            memberDetails = handleFunction(member)
+            memberComment = memberDetails.comment
+        }
+
+        objectChildren.push({
+            type:memberType,
+            name:memberName,
+            comment:memberComment,
+            source:memberSource,
+            details:memberDetails
+        })
+    }
+    return {type:"object",children:objectChildren}
+}
+
+const handleType = (memberType) => {
+    if (!memberType || !memberType.type) return {type:"unknown"}
+    else if (memberType.type == "intrinsic") return {type:"primitive",name:memberType.name}
+    else if (memberType.type == "array") return {type:"array",child:handleType(memberType.elementType)}
+    else if (memberType.type == "union") return {type:"union",children:memberType.types.map((t) => handleType(t))}
+    else if (memberType.type == "intersection") return {type:"intersection",children:memberType.types.map((t) => handleType(t))}
+    else if (memberType.type == "reference"){
+        const referenceTypeArguments = (memberType.typeArguments) ? memberType.typeArguments.map((ta) => handleType(ta)) : null
+        let referenceType = availableElements.find((el) => el.name == memberType.name)?.type ?? null
+
+        if (referenceType){
+            //member is known type (from Open Ticket)
+            return {type:"reference",name:memberType.name,target:referenceType,typeArguments:referenceTypeArguments}
+        }else if (memberType.package){
+            //member is type from node.js or another package
+            if (memberType.package == "typescript") return {type:"internal",name:memberType.name,typeArguments:referenceTypeArguments}
+            if (memberType.package == "open-ticket" && memberType.refersToTypeParameter) return {type:"typeParam",name:memberType.name,typeArguments:referenceTypeArguments}
+            else return {type:"external",package:memberType.package,name:memberType.name,typeArguments:referenceTypeArguments}
+        }else return {type:"unknown"}
+    }
+    else if (memberType.type == "literal") return {type:"literal",name:(typeof memberType.value == "string") ? JSON.stringify(memberType.value) : String(memberType.value)}
+    else if (memberType.type == "typeOperator"){
+        if (memberType.operator == "keyof") return {type:"keyof",child:handleType(memberType.target)}
+        else if (memberType.operator == "readonly") return {type:"readonly",child:handleType(memberType.target)}
+        else if (memberType.operator == "unique") return {type:"unique",child:handleType(memberType.target)}
+    }
+    else if (memberType.type == "conditional") return {type:"conditional",checker:handleType(memberType.checkType),extends:handleType(memberType.extendsType),trueValue:handleType(memberType.trueType),falseValue:handleType(memberType.falseType)}
+    else if (memberType.type == "indexedAccess") return {type:"index",index:handleType(memberType.indexType),object:handleType(memberType.objectType)}
+    else if (memberType.type == "mapped") return {type:"mapped",parameterName:memberType.parameter,parameter:handleType(memberType.parameterType),template:handleType(memberType.templateType)}
+    else if (memberType.type == "optional") return {type:"optional",child:handleType(memberType.elementType)}
+    else if (memberType.type == "predicate") return {type:"predicate",name:memberType.name,target:handleType(memberType.targetType)}
+    else if (memberType.type == "query") return {type:"query",target:handleType(memberType.queryType)}
+    else if (memberType.type == "rest") return {type:"rest",child:handleType(memberType.elementType)}
+    else if (memberType.type == "tuple") return {type:"tuple",children:memberType.elements.map((t) => handleType(t))}
+    else if (memberType.type == "templateLiteral") return {type:"template",head:memberType.head,tails:memberType.tail.map((t) => {
+        return {element:handleType(t[0]),text:t[1]}
+    })}
+    else if (memberType.type == "reflection" && memberType.declaration && memberType.declaration.signatures && memberType.declaration.signatures[0]){
+        return handleFunction(memberType.declaration)
+    }
+    else if (memberType.type == "reflection"){
+        return handleObject(memberType.declaration)
+    }
+    else return {type:"unknown"}
+}
+
+for (const file of result.children){
+    const classIds = file.groups?.find((g) => g.title == "Classes")?.children ?? []
+    const interfaceIds = file.groups?.find((g) => g.title == "Interfaces")?.children ?? []
+    const typeIds = file.groups?.find((g) => g.title == "Type Aliases")?.children ?? []
+    const enumIds = file.groups?.find((g) => g.title == "Enumerations")?.children ?? []
+    const varIds = file.groups?.find((g) => g.title == "Variables")?.children ?? []
+    const funcIds = file.groups?.find((g) => g.title == "Functions")?.children ?? []
+
+    for (const declaration of file.children){
+        const declarationName = declaration.name
+        const declarationType = classIds.includes(declaration.id) ? "class" : interfaceIds.includes(declaration.id) ? "interface" : typeIds.includes(declaration.id) ? "type" : enumIds.includes(declaration.id) ? "enum" : varIds.includes(declaration.id) ? "variable" : funcIds.includes(declaration.id) ? "function" : "other"
+        availableElements.push({name:declarationName,type:declarationType})
+    }
+}
+
+const exported = []
+for (const file of result.children){
+    const classIds = file.groups?.find((g) => g.title == "Classes")?.children ?? []
+    const interfaceIds = file.groups?.find((g) => g.title == "Interfaces")?.children ?? []
+    const typeIds = file.groups?.find((g) => g.title == "Type Aliases")?.children ?? []
+    const enumIds = file.groups?.find((g) => g.title == "Enumerations")?.children ?? []
+    const varIds = file.groups?.find((g) => g.title == "Variables")?.children ?? []
+    const funcIds = file.groups?.find((g) => g.title == "Functions")?.children ?? []
+
+    for (const declaration of (file.children ?? [])){
+        const declarationName = declaration.name
+        if (skipElementNames.includes(declarationName)) continue
+
+        const declarationType = classIds.includes(declaration.id) ? "class" : interfaceIds.includes(declaration.id) ? "interface" : typeIds.includes(declaration.id) ? "type" : enumIds.includes(declaration.id) ? "enum" : varIds.includes(declaration.id) ? "variable" : funcIds.includes(declaration.id) ? "function" : "other"
+        const declarationTypeParams = (declaration.typeParameters) ? declaration.typeParameters.map((tp) => {
+            return {name:tp.name,type:handleType(tp.type)}
+        }) : null
+        const declarationComment = declaration.comment?.summary?.map((c) => c.text).join("") ?? null
+        const declarationConstant = declaration.flags.isConst ? true : false
+        
+        const rawDeclarationSource = declaration.sources ? (declaration.sources[0] ?? null) : null
+        const declarationSource = rawDeclarationSource ? rawDeclarationSource.fileName+":"+rawDeclarationSource.line+":"+rawDeclarationSource.character : null
+
+        const declarationChildren = []
+        if (declarationType == "class"){
+            //CLASS
+            const constructorIds = declaration.groups?.find((g) => g.title == "Constructors")?.children ?? []
+            const propertyIds = declaration.groups?.find((g) => g.title == "Properties")?.children ?? []
+            const methodIds = declaration.groups?.find((g) => g.title == "Methods")?.children ?? []
+
+            for (const member of (declaration.children ?? [])){
+                const memberName = member.name
+                const memberType = constructorIds.includes(member.id) ? "constructor" : propertyIds.includes(member.id) ? "property" : methodIds.includes(member.id) ? "method" : "other"
+                let memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+                
+                const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+                let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+                const memberInherited = member.flags.isInherited ? true : false
+                const memberStatic = member.flags.isStatic ? true : false
+                const memberProtected = member.flags.isProtected ? true : false
+                const memberOptional = member.flags.isOptional ? true : false
+                const memberReadonly = member.flags.isReadonly ? true : false
+
+                let memberDetails = null
+                if (memberType == "property"){
+                    //CLASS => PROPERTY
+                    memberDetails = handleType(member.type)
+
+                }else if (memberType == "method"){
+                    //CLASS => METHOD
+                    memberDetails = handleFunction(member)
+                    memberComment = memberDetails.comment
+                    
+                }else if (memberType == "constructor"){
+                    //CLASS => CONSTRUCTOR
+                    memberDetails = handleFunction(member)
+                    memberComment = memberDetails.comment
+                }
+
+                declarationChildren.push({
+                    type:memberType,
+                    name:memberName,
+                    comment:memberComment,
+                    source:memberSource,
+                    details:memberDetails,
+                    inherited:memberInherited,
+                    static:memberStatic,
+                    protected:memberProtected,
+                    optional:memberOptional,
+                    readonly:memberReadonly
+                })
+            }
+        }else if (declarationType == "interface"){
+            //INTERFACE
+            const propertyIds = declaration.groups?.find((g) => g.title == "Properties")?.children ?? []
+            const methodIds = declaration.groups?.find((g) => g.title == "Methods")?.children ?? []
+
+            for (const member of (declaration.children ?? [])){
+                const memberName = member.name
+                const memberType = propertyIds.includes(member.id) ? "property" : methodIds.includes(member.id) ? "method" : "other"
+                let memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+                
+                const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+                let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+                const memberInherited = member.flags.isInherited ? true : false
+                const memberStatic = member.flags.isStatic ? true : false
+                const memberProtected = member.flags.isProtected ? true : false
+                const memberOptional = member.flags.isOptional ? true : false
+                const memberReadonly = member.flags.isReadonly ? true : false
+
+                let memberDetails = null
+                if (memberType == "property"){
+                    //INTERFACE => PROPERTY
+                    memberDetails = handleType(member.type)
+                }else if (memberType == "method"){
+                    //INTERFACE => METHOD
+                    memberDetails = handleFunction(member)
+                    memberComment = memberDetails.comment
+                }
+
+                declarationChildren.push({
+                    type:memberType,
+                    name:memberName,
+                    comment:memberComment,
+                    source:memberSource,
+                    details:memberDetails,
+                    inherited:memberInherited,
+                    static:memberStatic,
+                    protected:memberProtected,
+                    optional:memberOptional,
+                    readonly:memberReadonly
+                })
+            }
+        }else if (declarationType == "type"){
+            //TYPE
+            declarationChildren.push(handleType(declaration.type))
+        }else if (declarationType == "enum"){
+            //ENUM
+            const enumerableIds = declaration.groups?.find((g) => g.title == "Enumeration Members")?.children ?? []
+
+            for (const member of (declaration.children ?? [])){
+                const memberName = member.name
+                const memberType = enumerableIds.includes(member.id) ? "enumerable" : "other"
+                const memberComment = member.comment?.summary?.map((c) => c.text).join("") ?? null
+                
+                const rawMemberSource = member.sources ? (member.sources[0] ?? null) : null
+                let memberSource = rawMemberSource ? rawMemberSource.fileName+":"+rawMemberSource.line+":"+rawMemberSource.character : null
+
+                let memberDetails = null
+                if (memberType == "enumerable"){
+                    //ENUM => ENUMERABLE
+                    memberDetails = handleType(member.type)
+                }
+
+                const memberInherited = member.flags.isInherited ? true : false
+                const memberStatic = member.flags.isStatic ? true : false
+                const memberProtected = member.flags.isProtected ? true : false
+                const memberOptional = member.flags.isOptional ? true : false
+                const memberReadonly = member.flags.isReadonly ? true : false
+
+                declarationChildren.push({
+                    type:memberType,
+                    name:memberName,
+                    comment:memberComment,
+                    source:memberSource,
+                    details:memberDetails,
+                    inherited:memberInherited,
+                    static:memberStatic,
+                    protected:memberProtected,
+                    optional:memberOptional,
+                    readonly:memberReadonly
+                })
+            }
+        }else if (declarationType == "variable"){
+            //VARIABLE
+            declarationChildren.push(handleType(declaration.type))
+
+        }else if (declarationType == "function"){
+            //FUNCTION
+            declarationChildren.push(handleFunction(declaration))
+            
+        }
+
+        exported.push({
+            type:declarationType,
+            name:declarationName,
+            comment:declarationComment,
+            constant:declarationConstant,
+            source:declarationSource,
+            children:declarationChildren,
+            typeParams:declarationTypeParams
+        })
+    }
+}
+
+fs.writeFileSync(".docs/result.json",JSON.stringify(exported,null,"\t"))
+fs.rmSync(".docs/typedoc-result.json")

.docs/typedoc-config.json

@@ -0,0 +1,13 @@
+{
+    "$schema": "https://typedoc.org/schema.json",
+    "entryPoints": [
+        "../src/core/api/modules/",
+        "../src/core/api/defaults/",
+        "../src/core/api/openticket/",
+        "../src/core/api/main.ts",
+        "../src/core/startup/init.ts",
+    ],
+    "entryPointStrategy": "expand",
+    "json": "./typedoc-result.json",
+    "basePath": "../"
+}

.eggs/README.md

@@ -0,0 +1,47 @@
+# Pterodactyl Eggs
+<img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="500px">
+
+[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)
+[![version](https://img.shields.io/badge/version-4.0.3-brightgreen.svg?style=flat-square)](https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.3)
+[![Sponsor DJj123dj](https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors)](https://github.com/sponsors/DJj123dj)
+[![Open Ticket supports Pterodactyl Eggs!](https://img.shields.io/badge/pterodactyl-supported-10539F?style=flat-square&logo=pterodactyl)](.eggs/README.md)
+
+
+Hi there! Open Ticket provides **official eggs** for the Pterodactyl & Pelican panels!<br>
+There are different eggs for different versions of Open Ticket.
+Please choose the one that fits your needs the most.
+
+If you encounter any issues while installing these eggs, please head to our [**discord server**](https://discord.dj-dj.be) for further assistance!
+
+### Requirements
+It's recommended to provide at least `1GB` of **Memory/RAM** and `5GB` of **disk space** for Open Ticket to work correctly.
+
+### Egg Variants
+[**`openticket-egg-main.json` (Recommended)**](openticket-egg-main.json)
+- This egg will use the `main` branch of Open Ticket.
+
+[**`openticket-egg-v4.0.3.json`**](openticket-egg-v4.0.3.json)
+- This egg will always use Open Ticket `v4.0.3`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v4.0.2.json`**](openticket-egg-v4.0.2.json)
+- This egg will always use Open Ticket `v4.0.2`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v4.0.1.json`**](openticket-egg-v4.0.1.json)
+- This egg will always use Open Ticket `v4.0.1`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v4.0.0.json`**](openticket-egg-v4.0.0.json)
+- This egg will always use Open Ticket `v4.0.0`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-v3.5.9.json`**](openticket-egg-v3.5.9.json)
+- This egg will always use Open Ticket `v3.5.9`. Open Ticket updates will not have an effect on this egg.
+
+[**`openticket-egg-dev.json` (Not Recommended)**](openticket-egg-dev.json)
+- This egg will use the `dev` branch of Open Ticket.
+
+---
+<img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="170px">
+
+**Pterodactyl Eggs**<br>
+[changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be)<br>
+
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)

.eggs/openticket-egg-dev.json

@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:21+01:00",
+    "name": "Open Ticket (Experimental)",
+    "author": "support@dj-dj.be",
+    "description": "This is the experimental Pterodactyl egg for Open Ticket, the most advanced & customisable discord ticket bot that you will ever find! DO NOT USE IN PRODUCTION!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (dev)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"dev\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}

.eggs/openticket-egg-main.json

@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:20+01:00",
+    "name": "Open Ticket (Latest)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (main)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"main\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}

.eggs/openticket-egg-v3.5.9.json

@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:19+01:00",
+    "name": "Open Ticket (v3.5.9)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v3.5.9, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v3.5.9)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v3.5.9\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}

.eggs/openticket-egg-v4.0.0.json

@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.0)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.0, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.0)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.0\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}

.eggs/openticket-egg-v4.0.1.json

@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.1)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.1, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.1)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.1\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}

.eggs/openticket-egg-v4.0.2.json

@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.2)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.2, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.2)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.2\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}

.eggs/openticket-egg-v4.0.3.json

@@ -0,0 +1,62 @@
+{
+    "_comment": "DO NOT EDIT: FILE GENERATED AUTOMATICALLY BY PTERODACTYL PANEL - PTERODACTYL.IO",
+    "meta": {
+        "version": "PTDL_v2",
+        "update_url": null
+    },
+    "exported_at": "2025-03-16T18:10:18+01:00",
+    "name": "Open Ticket (v4.0.3)",
+    "author": "support@dj-dj.be",
+    "description": "This is the official Pterodactyl egg for Open Ticket v4.0.3, the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes Html Transcripts, Advanced Plugins, Custom Embeds, Questions\/Modals, Stats & more!",
+    "features": null,
+    "docker_images": {
+        "ghcr.io\/parkervcp\/yolks:nodejs_20": "ghcr.io\/parkervcp\/yolks:nodejs_20"
+    },
+    "file_denylist": [],
+    "startup": "if [[ ! -z ${NODE_PACKAGES} ]]; then npm install ${NODE_PACKAGES}; fi; if [[ ! -z ${UNNODE_PACKAGES} ]]; then npm uninstall ${UNNODE_PACKAGES}; fi; if [ -f \/home\/container\/package.json ]; then npm install; fi; node \"\/home\/container\/index.js\" ${NODE_FLAGS};",
+    "config": {
+        "files": "{}",
+        "startup": "{\r\n    \"done\": \"STARTUP INFO:\"\r\n}",
+        "logs": "{}",
+        "stop": "^C"
+    },
+    "scripts": {
+        "installation": {
+            "script": "#!\/bin\/bash\r\n# Open Ticket Installation Script (v4.0.3)\r\n# Inspired by: Node.js Installation Script\r\n# \u00a9 DJdj Development\r\n\r\necho -e \"[OT INSTALLER] installing dependencies. please wait...\"\r\napt update\r\napt install -y git curl\r\n\r\necho -e \"[OT INSTALLER] updating npm. please wait...\"\r\nnpm install npm@latest --location=global\r\n\r\nmkdir -p \/mnt\/server\r\ncd \/mnt\/server\r\n\r\nBRANCH=\"v4.0.3\"\r\n\r\nif [ \"$(ls -A \/mnt\/server)\" ]; then\r\n    echo -e \"[OT INSTALLER] \/mnt\/server directory is not empty.\"\r\n    if [ -d .git ]; then\r\n        echo -e \"[OT INSTALLER] .git directory exists\"\r\n        if [ -f .git\/config ]; then\r\n            echo -e \"[OT INSTALLER] loading info from git config\"\r\n            ORIGIN=$(git config --get remote.origin.url)\r\n        else\r\n            echo -e \"[OT INSTALLER] files found with no git config\"\r\n            echo -e \"[OT INSTALLER] closing out without touching things to not break anything\"\r\n            exit 10\r\n        fi\r\n    fi\r\n\r\n    if [ \"${ORIGIN}\" == \"https:\/\/github.com\/open-discord-bots\/open-ticket.git\" ]; then\r\n        echo \"pulling latest from github\"\r\n        git pull\r\n    fi\r\nelse\r\n    echo -e \"[OT INSTALLER] \/mnt\/server is empty.\"\r\n    echo -e \"[OT INSTALLER] cloning files into repo.\"\r\n    if [ -z ${BRANCH} ]; then\r\n        echo -e \"[OT INSTALLER] cloning default branch\"\r\n        git clone https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    else\r\n        echo -e \"[OT INSTALLER] cloning ${BRANCH}'\"\r\n        git clone --single-branch --branch ${BRANCH} https:\/\/github.com\/open-discord-bots\/open-ticket.git .\r\n    fi\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing Open Ticket node.js packages.\"\r\nif [ -f \/mnt\/server\/package.json ]; then\r\n    \/usr\/local\/bin\/npm install --omit=dev\r\nfi\r\n\r\necho -e \"[OT INSTALLER] installing custom node.js packages.\"\r\nif [[ ! -z ${NODE_PACKAGES} ]]; then\r\n    \/usr\/local\/bin\/npm install ${NODE_PACKAGES}\r\nfi\r\n\r\necho -e \"[OT INSTALLER] install complete!\"\r\nexit 0",
+            "container": "node:latest",
+            "entrypoint": "bash"
+        }
+    },
+    "variables": [
+        {
+            "name": "Additional Npm Packages",
+            "description": "Specify additional npm packages used by Open Ticket plugins. Use spaces to separate.",
+            "env_variable": "NODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Startup Flags",
+            "description": "Start the bot with additional Open Ticket flags. Separate using spaces.\r\nA full reference list can be found in the documentation.",
+            "env_variable": "NODE_FLAGS",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        },
+        {
+            "name": "Uninstall Npm Packages",
+            "description": "A list of npm packages to uninstall. Separate by spaces.",
+            "env_variable": "UNNODE_PACKAGES",
+            "default_value": "",
+            "user_viewable": false,
+            "user_editable": true,
+            "rules": "string|nullable",
+            "field_type": "text"
+        }
+    ]
+}

.github/CONTENT_CREATORS.md

@@ -1,19 +1,17 @@
 # 🎥 Content Creators
 Hi there! We're searching for content creators to create tutorials & setup guides for Open Ticket.
-You can get many great rewards from helpin us!
+You can get many great rewards from helping us!
 
 You can choose which type of tutorial you want to make. You can create a quick setup, full setup, plugin tutorial or something else!
 You are not required to talk in the video, but make sure it has some kind of subtitles instead.
 
 ### 📄 Requirements
-- 📌 At least 2k subscribers!
+- 📌 Video length of at least 2 minutes.
-- 📌 A little bit of channel activity! *(minimum 2 uploads/month)*
+- 📌 Provide a link to the Open Ticket repository in the description of the video.
-- 📌 Video length of at least 3 minutes!
+- 📌 Please use the latest version of Open Ticket available at the time of making the video.
-- 📌 Provide a clear link to the Open Ticket repository!
+- 📌 **(Optional)** Recommended language is English.
-- 📌 Recommended language is English!
+- 📌 **(Optional)** Recommended platform is YouTube!
-- 📌 Recommended platform is YouTube!
+- 📌 **(Optional)** Speech in the video *(AI is allowed)*
-- 📌 Must be for the latest version of Open Ticket!
-- 📌 **(OPTIONAL)** Speech in the video *(AI is allowed)*
 
 
 ### 🎁 Rewards

.github/CONTRIBUTING.md

@@ -1,7 +1,7 @@
 # Contributing Guidelines
 <img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="500px">
 
-[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.0-brightgreen.svg?style=flat-square)](https://github.com/DJj123dj/open-ticket/releases/tag/v4.0.0)
+[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.3-brightgreen.svg?style=flat-square)](https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.3)  [![Sponsor DJj123dj](https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors)](https://github.com/sponsors/DJj123dj)
 
 These are the Contributing Guidelines of Open Ticket!<br>
 Here you can find everything you need to know about contributing to Open Ticket.<br>
@@ -36,7 +36,7 @@ Metadata can be found in the `_TRANSLATION` variable.
 #### Step 4: Uploading
 1. When adding a new language, please mention @DJj123dj. He will add the code required for the language to work.
 2. There are currently 3 ways of uploading translations:
-   -  Create a pull request to the [__`dev` branch!__](https://github.com/DJj123dj/open-ticket/tree/dev)
+   -  Create a pull request to the [__`dev` branch!__](https://github.com/open-discord-bots/open-ticket/tree/dev)
    -  Create a ticket in our [discord server](https://discord.dj-dj.be)!
    -  Send a DM to @DJj123dj on discord!
 3. Now you'll need to wait until the next Open Ticket version for it to be added.
@@ -89,4 +89,4 @@ you are **REQUIRED to send the bug privately via one of the following methods:**
 **Contributing Guidelines**<br>
 [changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be)<br>
 
-© 2024 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,9 +1,7 @@
 ---
 name: Bug Report
 about: Report bugs to help us improve Open Ticket!
-title: "[BUG] Your Bug"
+title: "Your Bug Name"
-labels: bug
-assignees: DJj123dj
 ---
 
 ### Bug Description:

.github/ISSUE_TEMPLATE/documentation.md

@@ -0,0 +1,27 @@
+---
+name: Documentation
+about: Do you know anything to be improved in the Open Ticket documentation?
+title: "Documentation Improvement Name"
+labels: "Documentation"
+---
+
+### Related Docs/Systems:
+Choose related systems/docs for this improvement/change:
+- [ ] Guides
+- [ ] Developer Guides
+- [ ] API Reference
+- [ ] Blog
+- [ ] System (Docusaurus & Javascript)
+- [ ] Assets (images)
+- [ ] Other
+
+### Improvement Description:
+A clear and concise description of the improvement.
+
+> Please explain it as detailed as possible!
+
+### Screenshots:
+If applicable, add screenshots to help explain your request.
+
+### Additional Notes:
+Add any other context about the request here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,27 @@
+---
+name: Feature Request
+about: Do you have a great idea for Open Ticket? Let us know using this issue!
+title: "Your Feature Name"
+labels: "Concept"
+---
+
+### Feature Description:
+A clear and concise description of what the feature is.
+
+### Affected Systems
+Systems which are affected, improved or modified:
+- (example) Slash command registration...
+- (example) API embed builders...
+- Scroll down to '....'
+- See error
+
+> Leave empty when you don't know which parts this feature affects!
+
+### Advantages & Use Cases:
+What advantages & use cases do you think this feature would result in?
+
+### Screenshots:
+If applicable, add screenshots to help explain your feature request.
+
+### Additional Notes:
+Add any other context about the request here.

.github/ISSUE_TEMPLATE/html_transcripts.md

@@ -0,0 +1,20 @@
+---
+name: HTML Transcripts
+about: Found a bug related to the HTML Transcripts? Or do you have a feature request?
+title: "Your Bug/Improvement Name"
+labels: "HTML Transcripts"
+---
+
+### Feature/Bug Description:
+A clear and concise description of what the feature/bug report is.
+
+### Screenshots:
+If applicable, add screenshots to help explain your feature request or bug report.
+
+### Files:
+Please include the `otdebug.txt` file in your report! With this file, we can take a deep-dive in to the error that happend.
+> #### Include this file for bug reports!
+> This file doesn't contain any credentials or sensitive information!
+
+### Additional Notes:
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/new_language.md

@@ -0,0 +1,30 @@
+---
+name: New Language
+about: Do you want to add a new language to Open Ticket?
+title: "Language Name"
+labels: "New Translation"
+---
+
+### Language Name
+The name of the new language.
+
+### Language Description/Details:
+A clear and concise description of the translation/language.
+
+### Checklist
+Before the language is fully implemented, the following checklist must be met:
+- [ ] **📌 Created a language file in the `./languages/` directory.**
+- [ ] **📌 The translation file uses the `<lowercase-language-name>.json` format.**
+- [ ] **📌 The `"_TRANSLATION"` metadata in the language file is correctly configured.**
+  - [ ] The `"otversion"` is correct.
+  - [ ] The `"translators"` list is up to date has the discord/github usernames from all translators.
+  - [ ] The `"lastedited"` variable is the last edited date in the following format: `DD/MM/YYYY`.
+  - [ ] The `"language"` variable is the name of the language in English.
+  - [ ] `"automated"` is enabled when `Google Translate`, `DeepL`, `ChatGPT` or any other kind of translation tools were used.
+- [ ] **📌 The language has been added to the `README.md` list.**
+- [ ] **📌 The language counters have been updated in the `README.md`.**
+- [ ] **📌 The language has been added to the list in the `ODLanguageManagerIds_Default` interface in (`./src/core/api/defaults/language.ts`).**
+- [ ] **📌 The language has been added to the list in `./src/data/languageLoader.ts`.**
+
+### Additional Notes:
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/plugin_request.md

@@ -0,0 +1,20 @@
+---
+name: Plugin Request
+about: Do you have an idea for an Open Ticket plugin?
+title: "Your Plugin Name"
+labels: "Plugin"
+---
+
+### Plugin Description:
+A clear and concise description of what the plugin is & does.
+
+> Please explain the plugin as detailed as possible!
+
+### Advantages & Use Cases:
+What advantages & use cases do you think this plugin would result in?
+
+### Screenshots:
+If applicable, add screenshots to help explain your plugin request.
+
+### Additional Notes:
+Add any other context about the request here.

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,28 @@
+---
+name: Question
+about: Do you have a question about Open Ticket?
+title: "My Question"
+labels: "Question"
+---
+
+### Question:
+A clear and concise description of the question.
+
+> Please explain the question as detailed as possible!
+
+### Screenshots:
+If applicable, add screenshots to help explain your plugin request.
+
+### Checklist:
+Before creating this question, the following checklist must be met:
+- [ ] **📌 I've read the docs (https://otdocs.dj-dj.be) and I didn't found the solution.**
+- [ ] **📌 I've asked other people & they didn't know the solution.**
+- [ ] **📌 The question is not related to the following subjects: (If so, ask it in our discord server: https://discord.dj-dj.be)**
+  -  Configuring the bot
+  -  Hosting the bot (24/7)
+  -  Updating the bot
+- [ ] **📌 I know that this issue is publicly visible for everyone and I haven't shared any private info.**
+
+
+### Additional Notes:
+Add any other context about the request here.

.github/ISSUE_TEMPLATE/updated_language.md

@@ -0,0 +1,24 @@
+---
+name: Updated Language
+about: Do you want to update/improve an existing language in Open Ticket?
+title: "Language Name"
+labels: "Updated Translation"
+---
+
+### Language Name
+The name of the existing language.
+
+### Language Description/Details:
+A clear and concise description of the translation/language changes.
+
+### Checklist
+Before the language is updated, the following checklist must be met:
+- [ ] **📌 The `"_TRANSLATION"` metadata in the language file is correctly configured.**
+  - [ ] The `"otversion"` is correct.
+  - [ ] The `"translators"` list is up to date has the discord/github usernames from all translators.
+  - [ ] The `"lastedited"` variable is the last edited date in the following format: `DD/MM/YYYY`.
+  - [ ] The `"language"` variable is the name of the language in English.
+  - [ ] `"automated"` is enabled when `Google Translate`, `DeepL`, `ChatGPT` or any other kind of translation tools were used.
+
+### Additional Notes:
+Add any other context about the problem here.

.github/SECURITY.md

@@ -1,7 +1,7 @@
 # Security Policy
 <img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="500px">
 
-[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.0-brightgreen.svg?style=flat-square)](https://github.com/DJj123dj/open-ticket/releases/tag/v4.0.0)
+[![discord](https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord)](https://discord.com/invite/26vT9wt3n3)  [![version](https://img.shields.io/badge/version-4.0.3-brightgreen.svg?style=flat-square)](https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.3)  [![Sponsor DJj123dj](https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors)](https://github.com/sponsors/DJj123dj)
 
 This is the Security Policy of Open Ticket!<br>
 Here you can find a list of all supported & deprecated versions of the bot.<br>
@@ -11,7 +11,7 @@ You will also find some guidelines about how to report vulnerabilities, bugs & e
 Below, you can find a list with the status of every Open Ticket version.<br>
 This list will be updated on every release.
 
-- 🟦 Early Access **(ideas, bugs, support, html transcripts)**
+- 🟦 In Development **(ideas, bugs, support, html transcripts)**
 - ✅ Supported **(features, bugs, support, docs, html transcripts)**
 - 🚧 Maintenance **(support, docs, html transcripts)**
 - 🟧 Deprecated **(docs)**
@@ -19,12 +19,14 @@ This list will be updated on every release.
 
 | Version    | Supported | Notes                          |
 |------------|-----------|--------------------------------|
-| 4.0.0-beta | 🟦        | For v4.0.0 Full Release        |
+| 4.1.0      | 🟦        |                                |
-| 3.5.8      | ✅        | Supported until October 2024   |
+| 4.0.3      | ✅        |                                |
-| 3.5.7      | ✅        | Supported until September 2024 |
+| 4.0.2      | ✅        | Major discord.js bug           |
-| 3.5.6      | 🟧        | Documentation Only             |
+| 4.0.1      | ✅        |                                |
-| < 3.5.6    | 🟧        | Documentation Only             |
+| 4.0.0      | 🚧        | Supported until May 2025       |
-| < 3.5.0    | ❌        |                                |
+| 3.5.9      | 🚧        | Supported until May 2025 (LTS) |
+| 3.5.8      | 🟧        | Documentation Only             |
+| < 3.5.8    | ❌        |                                |
 
 ### 🕷️ Reporting Vulnerabilities
 You can report vulnerabilities, errors & bugs using one of the following methods:
@@ -46,4 +48,4 @@ If possible, try to provide screenshots!
 **Security Policy**<br>
 [changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be)<br>
 
-© 2024 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)

.gitignore

@@ -1,16 +1,22 @@
 node_modules/
 package-lock.json
+.vscode/
+
 devconfig/
 devdatabase/
+plugins/*
+!plugins/example-plugin/
+database/openticket.sqlite
+dist/
+
 otdebug.txt
+
 .DS_Store
 */.DS_Store
 */*/.DS_Store
 */*/*/.DS_Store
 **/.DS_Store
-TEMP/
+
-.vscode/
+.docs/*
-plugins/*
+!.docs/createDocs.js
-!plugins/example-plugin/
+!.docs/typedoc-config.json
-dist/
-database/openticket.sqlite

LICENSE.md

@@ -1,3 +1,7 @@
+# Open Ticket (License)
+© 2025 - DJj123dj & Contributors
+
+```
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
@@ -70,7 +74,7 @@ modification follow.
 
                        TERMS AND CONDITIONS
 
-  0. Definitions.
+  1. Definitions.
 
   "This License" refers to version 3 of the GNU General Public License.
 
@@ -671,4 +675,16 @@ into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
+```
+
+### Additional Terms for Open Ticket
+The following additional terms apply to the use of this software:
+
+1. This software may not be used as part of a public Discord bot service that is monetized (e.g., generating revenue through subscriptions, donations, or other forms of payment) without the prior written permission of the original author.
+
+2. This software may not be used as part of a public Discord bot service on multiple Discord servers without attribution to the original author.
+
+3. You are allowed to use this bot in a Discord server that makes money or is for-profit, provided that the income is not generated directly from the ticket bot or its functionality.
+
+These additional terms are an extension to the GNU GPL v3 and must be followed alongside the original license terms. In case of any conflict between these additional terms and the GNU GPL v3, the additional terms shall take precedence.

README.md

@@ -8,100 +8,70 @@
 <br>Powered By<br>
 <img src="https://apis.dj-dj.be/cdn/opendiscord/logo.png" alt="Open Ticket" width="170px"><br>
 <a href="https://discord.com/invite/26vT9wt3n3"><img alt="Discord Invite Link" src="https://img.shields.io/badge/discord-support%20server-5865F2.svg?style=flat-square&logo=discord"></img></a>
-<a href="https://github.com/DJj123dj/open-ticket/releases/tag/v4.0.0"><img alt="Open Ticket Version" src="https://img.shields.io/badge/version-4.0.0-brightgreen.svg?style=flat-square"></img></a>
+<a href="https://github.com/open-discord-bots/open-ticket/releases/tag/v4.0.3"><img alt="Open Ticket Version" src="https://img.shields.io/badge/version-4.0.3-brightgreen.svg?style=flat-square"></img></a>
 <a href="https://otdocs.dj-dj.be"><img alt="Open Ticket Documentation" src="https://img.shields.io/badge/discord.js-v14-CB3837.svg?style=flat-square&logo=npm"></img></a>
-<a href="https://github.com/DJj123dj/open-ticket/blob/main/LICENSE"><img alt="Open Ticket License" src="https://img.shields.io/badge/license-GPL%203.0-important.svg?style=flat-square"></img></a>
+<a href="https://github.com/open-discord-bots/open-ticket/blob/main/LICENSE"><img alt="Open Ticket License" src="https://img.shields.io/badge/license-GPL%203.0-important.svg?style=flat-square"></img></a>
 <a href="https://otdocs.dj-dj.be"><img alt="Open Ticket Stars" src="https://img.shields.io/github/stars/djj123dj/open-ticket?color=yellow&label=stars&logo=github&style=flat-square"></img></a>
+<br>
+<a href="https://github.com/sponsors/DJj123dj"><img alt="Sponsor DJj123dj" src="https://img.shields.io/badge/sponsor-DJj123dj-ea4aaa?style=flat-square&logo=githubsponsors"></img></a>
+<a href="https://hub.docker.com/repository/docker/djj123dj/open-ticket"><img alt="Open Ticket supports Docker!" src="https://img.shields.io/badge/docker-supported-2496ED?style=flat-square&logo=docker"></img></a>
+<a href=".eggs/README.md"><img alt="Open Ticket supports Pterodactyl Eggs!" src="https://img.shields.io/badge/pterodactyl-supported-10539F?style=flat-square&logo=pterodactyl"></img></a>
 </p>
 
 <p align="center">
 Open Ticket is the most advanced & customisable discord ticket bot that you will ever find! You can customise up to 300+ variables! This includes <code>Html Transcripts</code>, <code>Advanced Plugins</code>, <code>Custom Embeds</code>, <code>Questions/Modals</code>, <code>Stats</code> & more!
-You're also able to customise every little aspect of the bot! From embeds to transcripts. Open Ticket is also translated in more than <code>19 Languages</code>! If you need any help, feel free to join our <a href="https://discord.dj-dj.be">discord server</a>!
+You're also able to customise every little aspect of the bot! From embeds to transcripts. Open Ticket is also translated in more than <code>27 Languages</code>! If you need any help, feel free to join our <a href="https://discord.dj-dj.be">discord server</a>!
 </p>
 
 <p align="center"><b>⭐️ Help us grow by giving a star! ⭐️</b></p>
 
-> [!WARNING]  
-> Open Ticket v4 is still in beta! Please report all bugs in our [discord server](https://discord.dj-dj.be)!<br>
-> The translation count may not be accurate!
-
 ### 📌 Features
-- **💩 no bloat/credits** - Your Open Ticket bot doesn't contain any form of bloat or credits!
+- **🦇 pterodactyl support** - Open Ticket works perfect on Pterodactyl based panels! [(Download official eggs)](.eggs/README.md)
-- **📈 scalable** - Open Ticket is made to handle huge servers! Even if your server contains more than 100k members!
+- **💩 no bloat** - Your Open Ticket bot doesn't contain any form of bloat or credits!
-- **📄 html transcripts** - Make use of the most customisable, beautiful and easy-to-use HTML Transcripts!
+- **🔒 tested & secure** - Open Ticket has been battletested by thousands of servers and is very secure!
-- **✅ ticket actions** - Close, Reopen, Delete, Rename & Move all your tickets!
+- **📈 scalable** - Open Ticket is made to handle huge servers! (Already tested in **servers with 100k members**)
-- **🇬🇧 translation** - Open Ticket has been translated in more than **16 languages** by our community!
+- **📄 HTML transcripts** - Make use of the most customisable, beautiful and easy-to-use HTML Transcripts!
+- **✅ ticket actions** - Close, Reopen, Delete, Claim, Pin, Rename & Move all your tickets!
+- **🇬🇧 translation** - Open Ticket has been translated in more than **27 languages** by our community!
 - **🎨 customisation** - Open Ticket has been created around customisation, everything can be customised!
 - **🖥️ interactions** - The bot has full support for Buttons, Dropdowns, Slash Commands and Modals!
-- **∞ unlimited everywhere** - Create an infinite amount of tickets & panels!
+- **∞ unlimited** - Create an infinite amount of tickets & panels!
-- **📝 advanced plugins** - Create the most advanced plugins that you want or use premade ones by our community! 
+- **📝 advanced plugins** - Create advanced plugins or use pre-made ones by our community!
 - **👥 user management** - Add & Remove users from all tickets!
 - **📊 detailed stats** - Open Ticket has ticket, user & global staticstics available for everyone!
 - **🚫 blacklist** - Blacklist users to prevent them from creating a ticket!
 - **❓ questions** - Let users answer questions in a modal before the ticket is created!
-- **📦 commands** - Open Ticket supports both slash & text commands!
+- **📦 slash & text** - Open Ticket supports both slash & text commands!
-- **📥 extra types** - The bot also supports Reaction Roles & Url Buttons, because why not ¯\\_(ツ)_/¯
+- **📥 extra buttons** - The bot also supports Reaction Roles & Url Buttons, because why not ¯\\_(ツ)_/¯
-- **🎛️ dependencies** - We try to use as little external dependencies as needed!
+- **✨ commands** - The bot contains more than 25 commands!
-- **📢 commands** - The bot contains more than 25 commands! And it's expandable with plugins!
+
+#### And more using plugins!
+  - **💬 reviews** - Create & customise your own review system!
+  - **📢 feedback** - Collect feedback & create forms for people to answer!
+  - **🏷️ tags** - Create tags & answer questions automatically using keywords!
+  - **📝 forms** - Create advanced forms and ask people for additional details!
+  - **🔄 rotating status** - Create a rotating bot status & use dynamic variables from the bot!
+  - **💾 sqlite database** - Use an `sqlite` database for increased performances!
+  - **🎉 custom embeds** - Create your own embeds and use them in your server!
+  - **⏰ reminders** - Create & manage customisable reminders in your server!
+  - **🎨 customisation** - Yep, you heard it right! Even more customisation!
+  - **😁 And so much more...**
 
 > ### 📦 Resources
-> Resources might not be accurate yet! *(because v4 is still in beta)*<br>
+> Not all resources are accurate yet! We are working on this.<br>
 > <a href="https://www.youtube.com/watch?v=2jK9kAf6ASU"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-tutorial.png" alt="Open Ticket Tutorial" width="180px"></a>
-> <a href="https:/otdocs.dj-dj.be"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-docs.png" alt="Open Ticket Docs" width="180px"></a>
+> <a href="https://openticket.dj-dj.be/message.html?msg=The%20current%20tutorial%20is%20outdated,%20we%27re%20still%20working%20on%20a%20new%20one!"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-docs.png" alt="Open Ticket Docs" width="180px"></a>
-> <a href="https://github.com/DJj123dj/open-discord-plugins"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-plugins.png" alt="Open Ticket Plugins" width="180px"></a>
+> <a href="https://github.com/open-discord-bots/plugins"><img src="https://apis.dj-dj.be/cdn/openticket/open-ticket-plugins.png" alt="Open Ticket Plugins" width="180px"></a>
-
-## 📸 Preview
-<img alt="Ticket Message" width="550px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/ticket.png">
-<img alt="Ticket Stats Message" width="550px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/stats.png">
-<img alt="Example Panel 1" width="550px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/panel-1.png">
-<img alt="Example Panel 2" width="550px" src="https://apis.dj-dj.be/cdn/openticket/preview-v4/panel-2.png">
-
-## 🧩 Plugins
-View all available Open Ticket plugins in our [Official Plugin Repository](https://github.com/DJj123dj/open-discord-plugins)!
-
-### 📦 Official *(made by DJdj Development)*
-|Name                                                                 |Category                    |Description              |
-|---------------------------------------------------------------------|----------------------------|-------------------------|
-|[`example-plugin`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/example-plugin/)                     |Example                     |This is just an example plugin for people that want to create their own plugin. |
-|[`example-command`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/example-command/)                   |Example                     |Sample custom command using the Open Discord system. |
-|[`ot-jump-to-top`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-jump-to-top/)                     |Command                     |Add a simple command to jump to the top of the ticket. |
-|[`ot-kill-switch`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-kill-switch/)                     |Command                     |Temporarily disable the ticket system using a kill switch. |
-|[`ot-rename-keep-prefix`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-rename-keep-prefix/)       |Channel Management          |Simple plugin to keep the channel prefix when using the /rename command. |
-|[`ot-no-slash-clear`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-no-slash-clear/)               |Development                 |Disable the automatic removal of slash commands that aren't used by Open Ticket. |
-|[`ot-better-status`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-better-status/)                 |Client Activity             |An advanced status plugin to rotate between states. It also allows for the use of variables. |
-|[`ot-sqlite-database`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-sqlite-database/)             |Database                    |With this plugin, the database will be an SQLite file. It's a must-have for large servers! |
-|[`ot-ticket-message-extras`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-ticket-message-extras/) |Customisation               |A plugin which adds a few little features to the ticket message. |
-
-
-### ✅ Verified *(made by community)*
-|Name                                                                 |Author                      |Category                    |Description              |
-|---------------------------------------------------------------------|----------------------------|----------------------------|-------------------------|
-|[`ot-config-reload`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-config-reload/)                |guillee.3                   |Config                      |This plugin adds a new command that allows reloading the Open Ticket config files without the need for a restart. |
-|[`ot-feedback`](https://github.com/DJj123dj/open-discord-plugins/tree/main/open-ticket/ot-feedback/)                          |an_developer                |Feedback System             |A plugin to gather feedback of your support service. |
-
-## 🛠️ Contributors
-### 🖥️ Team
-The team behind Open Ticket!
-<table>
-<tr>
-<td><img src="https://github.com/DJj123dj.png" alt="Profile Picture" width="80px"></td>
-<td><img src="https://github.com/Sank34.png" alt="Profile Picture" width="80px"></td>
-</tr>
-<tr>
-<th><a href="https://github.com/DJj123dj">DJj123dj</a></th>
-<th><a href="https://github.com/Sank34">Sanke</a></th>
-</tr>
-</table>
 
 ### ❤️ Sponsors
 A big thanks to all our sponsors! Without them, it wouldn't be possible to create this project!
 
 <table>
 <tr>
-<td><img src="https://github.com/roppl3r.png" alt="Profile Picture" width="80px"></td>
+<td><img src="https://github.com/roppl3r.png" alt="Profile Picture" width="100px"></td>
 </tr>
 <tr>
-<th><a href="https://github.com/roppl3r">roppl3r</a></th>
+<td align="center"><a href="https://github.com/roppl3r"><b>roppl3r</b></a></td>
 </tr>
 </table>
 
@@ -110,60 +80,155 @@ A big thanks to all our sponsors! Without them, it wouldn't be possible to creat
 <img src="https://github.com/SpyEye2.png" alt="SpyEye" width="40px">
 <img src="https://github.com/mods-hd.png" alt="Mods HD" width="40px">
 <img src="https://github.com/DOSEV5.png" alt="DOSEV5" width="40px">
+<img src="https://github.com/BENZORICH.png" alt="BENZORICH" width="40px">
 </a>
 
+### ⏱️ Quick Setup
+> 1. Download the latest version of Open Ticket on [Github](https://github.com/open-discord-bots/open-ticket).
+> 2. Make sure node.js & npm are installed using `node -v` (minimum `v18`).
+> 3. Install any required dependencies using `npm install`.
+> 4. Configure the bot in the `./config/` directory.
+> 5. Start the bot using `npm start` or `node index.js`
+>    - The bot will let you know any existing config errors.
+>    - Fix these errors and restart the bot.
+> 6. Enjoy using Open Ticket!
+> ### [📔 Visit Documentation](https://otdocs.dj-dj.be)
+
+## 📸 Preview
+<img alt="An example of a panel." src="https://apis.dj-dj.be/cdn/openticket/preview-v4/panel-examples.png">
+<img alt="An example of a ticket message." src="https://apis.dj-dj.be/cdn/openticket/preview-v4/ticket-example.png">
+<img alt="Examples of built-in commands." src="https://apis.dj-dj.be/cdn/openticket/preview-v4/command-examples.png">
+
+## 🛠️ Contributors
+### 🖥️ Team & Contributors
+A list of people that contributed or provided the most support for Open Ticket.
+<table>
+<tr>
+<td align="center"><img src="https://github.com/DJj123dj.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/smetsliam.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/FrankVissers.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/Sank34.png" alt="Profile Picture" width="80px"></td>
+<td align="center"><img src="https://github.com/Roppl3r.png" alt="Profile Picture" width="80px"></td>
+</tr>
+<tr>
+<th><a href="https://github.com/DJj123dj">💻 DJj123dj</a></th>
+<th><a href="https://github.com/smetsliam">💬 smetsliam</a></th>
+<th><a href="https://github.com/FrankVissers">💬 Frank Vissers</a></th>
+<th><a href="https://github.com/Sank34">💬 Sanke</a></th>
+<th><a href="https://github.com/Roppl3r">🧩 Roppl3r</a></th>
+</tr>
+</table>
+
 ### 💬 Translators
-|Language             |Maintainer (discord name) |Status                       |
+Without our translators, it wouldn't be possible to translate Open Ticket in so many languages!
-|---------------------|--------------------------|-----------------------------|
+- 🟢 Available - 🤖 Made Using AI - 🔴 Unavailable/Outdated
-|🇬🇧 English            |djj123dj                  |🟢 Up To Date                |
+
-|🇳🇱 Dutch              |djj123dj                  |🟢 Up To Date                |
+|🔍 |Language             |Maintainer (Github/Discord) |
-|🇩🇪 German             |benzorich                 |🟢 Up To Date                |
+|---|---------------------|----------------------------|
-|🇪🇸 Spanish            |redactado & josuens       |🟢 Up To Date                |
+|🟢 |🇬🇧 English            |djj123dj                   |
-|🇵🇹 Portuguese         |quiradon                  |🟢 Up To Date                |
+|🟢 |🇳🇱 Dutch              |djj123dj                   |
-|❓ Catalan            |guillee3                  |🟢 Up To Date                |
+|🟢 |🇩🇪 German             |benzorich                  |
-|🇨🇿 Czech              |spyeye_                   |🟢 Up To Date                |
+|🟢 |🇪🇸 Spanish            |redactado & josuens        |
-|🇭🇺 Hungarian          |kornel0706                |🟢 Up To Date                |
+|🟢 |🇵🇹 Portuguese         |quiradon                   |
-|🇷🇴 Romanian           |sankedev                  |🟢 Up To Date                |
+|🟢 |❓ Catalan            |guillee3                   |
-|🇺🇦 Ukrainian          |anderskiy                 |🟢 Up To Date                |
+|🟢 |🇨🇿 Czech              |spyeye_                    |
-|🇮🇩 Indonesian         |erxg                      |🟢 Up To Date                |
+|🟢 |🇭🇺 Hungarian          |kornel0706                 |
-|🇮🇹 Italian            |fraden1mvp.               |🟢 Up To Date                |
+|🟢 |🇷🇴 Romanian           |sankedev                   |
-|🇩🇰 Danish             |the_gamer                 |🟢 Up To Date                |
+|🟢 |🇺🇦 Ukrainian          |anderskiy                  |
-|🇹🇭 Thai               |modshd                    |🟢 Up To Date                |
+|🟢 |🇮🇩 Indonesian         |erxg                       |
-|🇹🇷 Turkish            |palestinian               |🟢 Up To Date                |
+|🟢 |🇮🇹 Italian            |fraden1mvp.                |
-|🇫🇷 French             |guillee.3                 |🟢 Up To Date                |
+|🟢 |🇩🇰 Danish             |the_gamer                  |
-|🇦🇪 Arabic             |palestinian               |🟢 Up To Date                |
+|🟢 |🇹🇭 Thai               |modshd                     |
-|🇪🇪 Estonian           |iamnotmega                |🔵 Up To Date (ChatGPT)      |
+|🟢 |🇹🇷 Turkish            |palestinian                |
-|🇫🇮 Finnish            |iamnotmega                |🔵 Up To Date (ChatGPT)      |
+|🟢 |🇫🇷 French             |guillee.3                  |
-|🇷🇺 Russian            |apexo & ander             |🟠 Temporary Outdated (beta) |
+|🟢 |🇦🇪 Arabic             |palestinian                |
-|🇵🇱 Polish             |mkevas                    |🟠 Temporary Outdated (beta) |
+|🟢 |🇮🇳 Hindi              |an_developer               |
-|🇳🇴 Norwegian          |noonenook                 |🟠 Temporary Outdated (beta) |
+|🟢 |🇱🇹 Lithuanian         |tsgindrius                 |
-|❓ Kurdish            |raze.hama                 |🟠 Temporary Outdated (beta) |
+|🟢 |🇵🇱 Polish             |danoglez                   |
-|❓ Persian            |sasanwm                   |🟠 Temporary Outdated (beta) |
+|🟢 |🇳🇴 Norwegian          |NoOneNook                  |
-|🇱🇻 Latvian            |ronalds1398               |🟠 Temporary Outdated (beta) |
+|🟢 |🇸🇪 Swedish            |NoOneNook                  |
-|🇯🇵 Japanese           |iamnotmega                |🟠 Temporary Outdated (beta) |
+|🤖 |🇪🇪 Estonian           |iamnotmega                 |
-|🇰🇷 Korean             |iamnotmega                |🟠 Temporary Outdated (beta) |
+|🤖 |🇫🇮 Finnish            |iamnotmega                 |
-|🇨🇳 Simplified Chinese |iamnotmega                |🟠 Temporary Outdated (beta) |
+|🤖 |🇷🇺 Russian            |NoOneNook                  |
-|🇨🇳 Traditional Chinese|iamnotmega                |🟠 Temporary Outdated (beta) |
+|🤖 |🇱🇻 Latvian            |NoOneNook                  |
-|🇸🇪 Swedish            |iamnotmega                |🟠 Temporary Outdated (beta) |
+|🤖 |🇻🇳 Vietnamese         |ngocdiep2006               |
-|🇻🇳 Vietnamese         |iamnotmega                |🟠 Temporary Outdated (beta) |
+|🔴 |🇯🇵 Japanese           |[⭐ Contribute!](.github/CONTRIBUTING.md)|
-|🇸🇮 Slovenian          |n1kkec                    |🔴 Outdated                  |
+|🔴 |🇰🇷 Korean             |[⭐ Contribute!](.github/CONTRIBUTING.md)|
-|🇬🇷 Greek              |stefanos                  |🔴 Outdated                  |
+|🔴 |🇨🇳 Simplified Chinese |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇨🇳 Traditional Chinese|[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇸🇮 Slovenian          |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |🇬🇷 Greek              |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |❓ Kurdish            |[⭐ Contribute!](.github/CONTRIBUTING.md)|
+|🔴 |❓ Persian            |[⭐ Contribute!](.github/CONTRIBUTING.md)|
 
 ## ⭐️ Star History
-Please help us grow by giving a star! It would help us a lot!
+Please give this repository a star if you like it.  
+This will help us grow and reach even more people!
 
-<a href="https://star-history.com/#DJj123dj/open-ticket&Date">
+<a href="https://star-history.com/#open-discord-bots/open-ticket&Date">
  <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=DJj123dj/open-ticket&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=open-discord-bots/open-ticket&type=Date&theme=dark" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=DJj123dj/open-ticket&type=Date" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=open-discord-bots/open-ticket&type=Date" />
-   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=DJj123dj/open-ticket&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=open-discord-bots/open-ticket&type=Date" />
  </picture>
 </a>
 
+## 🧩 Plugins
+**Download all plugins in our [Official Plugin Repository](https://github.com/open-discord-bots/plugins)!**<br>
+> #### ⭐ Featured Plugins (Top 5 Most Used)
+> **[`ot-sqlite-database`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-sqlite-database/),
+> [`ot-migrate-v3`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-migrate-v3/),
+> [`ot-reviews`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-reviews/),
+> [`ot-feedback`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-feedback/),
+> [`ot-tags`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-tags/)**
+
+### 📦 Official *(made by DJdj Development)*
+|Name                                                                  |Category                    |Description              |
+|----------------------------------------------------------------------|----------------------------|-------------------------|
+|[`example-plugin`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/example-plugin/)                     |📄 Example                  |This is just an example plugin for people that want to create their own plugin. |
+|[`example-command`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/example-command/)                   |📄 Example                  |Sample custom command using the Open Discord system. |
+|[`ot-jump-to-top`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-jump-to-top/)                     |📢 Command                  |Add a simple command to jump to the top of the ticket. |
+|[`ot-kill-switch`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-kill-switch/)                     |📢 Command                  |Temporarily disable the ticket system using a kill switch. |
+|[`od-hosting-status`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-hosting-status/)               |📢 Command                  |A simple command to send hosting status updates to a channel. |
+|[`od-shutdown`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-shutdown/)                           |📢 Command                  |A simple command to turn off the bot from a slash command (server & bot owner only). |
+|[`ot-sqlite-database`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-sqlite-database/)             |⚙️ Utility                  |With this plugin, the database will be an SQLite file. It's a must-have for large servers! |
+|[`od-no-slash-clear`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-no-slash-clear/)               |⚙️ Utility                  |Disable the automatic removal of slash commands that aren't used by Open Ticket. |
+|[`ot-migrate-v3`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-migrate-v3/)                       |⚙️ Utility                  |Use this plugin to migrate all tickets from Open Ticket v3 to v4. |
+|[`ot-ticket-message-extras`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-ticket-message-extras/) |🎨 Customisation            |A plugin which adds a few little features to the ticket message. |
+|[`ot-rename-keep-prefix`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-rename-keep-prefix/)       |🎨 Customisation            |Simple plugin to keep the channel prefix when using the /rename command. |
+|[`ot-customise-buttons`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-customise-buttons/)         |🎨 Customisation            |Customise almost all built-in buttons. This includes the claim, reopen, close & delete buttons. |
+|[`ot-ephemeral-messages`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-ephemeral-messages/)       |🎨 Customisation            |Customise for every messages if it needs to be ephemeral or not. |
+|[`ot-footers`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-footers/)                             |🎨 Customisation            |A simple plugin to add footers in all Open Ticket embeds. |
+|[`od-alt-detector`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-alt-detector/)                   |💼 Management               |Use the discord-alt-detector npm package by DJdj Development in your ticket bot. |
+|[`ot-embeds`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-embeds/)                               |💼 Management               |Create custom premade embeds in the config or use the command to create one from scratch. |
+|[`ot-move-actions`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-move-actions/)                   |💼 Management               |Automatically unclaim/unpin a ticket when it's moved using `/move`. |
+|[`ot-reviews`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-reviews/)                             |💼 Management               |Review system for Open Ticket! It is very customisable and has lots of features. |
+|[`ot-tags`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-tags/)                                   |💼 Management               |Use tags to quickly reply with a pre-existing text. |
+|[`ot-better-status`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-better-status/)                 |🤖 Client                   |An advanced status plugin to rotate between states. It also allows for the use of variables. |
+
+### ✅ Verified *(made by community)*
+|Name                                                                 |Author                      |Category                    |Description              |
+|---------------------------------------------------------------------|----------------------------|----------------------------|-------------------------|
+|[`ot-config-reload`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-config-reload/)                |guillee.3                   |⚙️ Utility                  |This plugin adds a new command that allows reloading the Open Ticket config files without the need for a restart. |
+|[`ot-ticket-forms`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-ticket-forms/)                  |guillee.3                   |💼 Management               |An advanced forms plugin for Open Ticket. |
+|[`ot-feedback`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-feedback/)                          |an_developer                |💼 Management               |A plugin to gather feedback of your support service. |
+|[`ot-assign-role`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-assign-role/)                    |rapid.fast                  |💼 Management               |This plugin assigns a predefined role to a user upon creating a ticket. |
+|[`ot-volume-warning`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-volume-warning/)              |guillee.3                   |💼 Management               |Alerts ticket creators when too many tickets are open, indicating possible response delays. |
+|[`od-reminders`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/od-reminders/)                        |guillee.3                   |💼 Management               |Set reminders that will be sent to a channel every specified time. |
+|[`ot-translate-cmds`](https://github.com/open-discord-bots/plugins/tree/main/open-ticket/ot-translate-cmds/)              |guillee.3                   |🤖 Client                  |Translate all built-in command names, descriptions & options. |
+
+### 📢 Categories
+- **📄 Example** - These plugins serve as an example or starting template.
+- **📢 Command** - These plugins add new commands to the bot.
+- **⚙️ Utility** - These plugins help with backend & systems. You won't notice it in discord itself.
+- **🎨 Customisation** - These plugins help you customise the bot even further.
+- **💼 Management** - These plugins add features that help you manage your server.
+- **🤖 Client** - These plugins add features affecting the discord client or bot itself.
+
 ---
 <img src="https://apis.dj-dj.be/cdn/openticket/logo.png" alt="Open Ticket Logo" width="170px">
 
 **README.md**<br>
-[changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord](https://discord.dj-dj.be)<br>
+[changelog](https://otgithub.dj-dj.be/releases) - [documentation](https://otdocs.dj-dj.be) - [tutorial](https://www.youtube.com/watch?v=2jK9kAf6ASU) - [website](https://openticket.dj-dj.be) - [discord server](https://discord.dj-dj.be) - [license](./LICENSE.md)<br>
 
-© 2024 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms#terms) - [Privacy Policy](https://www.dj-dj.be/terms#privacy)
+© 2025 - [DJdj Development](https://www.dj-dj.be) - [Terms](https://www.dj-dj.be/terms) - [Privacy Policy](https://www.dj-dj.be/privacy) - [Support Us](https://github.com/sponsors/DJj123dj)

config/general.json

@@ -2,10 +2,10 @@
     "_INFO":{
         "support":"https://otdocs.dj-dj.be",
         "discord":"https://discord.dj-dj.be",
-        "version":"open-ticket-v4.0.0"
+        "version":"open-ticket-v4.0.3"
     },
     
-    "token":"your bot token here! Or leave empty when you use tokenFromENV",
+    "token":"your bot token here! (or leave empty when using 'tokenFromENV')",
     "tokenFromENV":false,
 
     "mainColor":"#f8ba00",

config/options.json

@@ -30,7 +30,7 @@
         
         "dmMessage":{
             "enabled":false,
-            "text":"Thanks for creating a ticket in our server! (or leave empty)",
+            "text":"Thank you for creating a ticket in our server! (or leave empty)",
             "embed":{
                 "enabled":false,
                 "title":"Embed Title! (or leave empty)",
@@ -51,7 +51,7 @@
             "embed":{
                 "enabled":true,
                 "title":"Question Ticket",
-                "description":"Thanks for creating a 'Question' ticket in our server!\nOur support team will help you soon!",
+                "description":"Thank you for creating a 'Question' ticket in our server!\nOur support team will help you as soon as possible!",
                 "customColor":"#f8ab00 (or leave empty)",
 
                 "image":"https://www.example.com/image.png (or leave empty)",
@@ -70,13 +70,13 @@
         "autoclose":{
             "enableInactiveHours":false,
             "inactiveHours":24,
-            "enableUserLeave":true,
+            "enableUserLeave":false,
             "disableOnClaim":false
         },
         "autodelete":{
             "enableInactiveDays":false,
             "inactiveDays":7,
-            "enableUserLeave":true,
+            "enableUserLeave":false,
             "disableOnClaim":false
         },
         "cooldown":{

config/panels.json

@@ -17,7 +17,7 @@
             "image":"https://www.example.com/image.png (or leave empty)",
             "thumbnail":"https://www.example.com/image.png (or leave empty)",
             
-            "footer":"Open Ticket v4.0.0 (or leave empty)",
+            "footer":"Open Ticket v4.0.3 (or leave empty)",
             "fields":[
                 {"name":"field name","value":"field value","inline":false}
             ],

config/transcripts.json

@@ -31,15 +31,13 @@
         "background":{
             "enableCustomBackground":false,
             "backgroundColor":"#f8ba00 (or leave empty)",
-            "backgroundImage":"https://www.example.com/image.png (or leave empty)"
+            "backgroundImage":"https://www.example.com/image.png (or leave empty)" 
-            
         },
         "header":{
             "enableCustomHeader":false,
             "backgroundColor":"#202225",
             "decoColor":"#f8ba00",
             "textColor":"#ffffff"
-            
         },
         "stats":{
             "enableCustomStats":false,

database/global.json

@@ -1,7 +1 @@
-[
+[]
-    {"category":"openticket:last-version","key":"openticket:version","value":"v4.0.0"},
-    {"category":"openticket:last-version","key":"openticket:api","value":"v1.0.0"},
-    {"category":"openticket:last-version","key":"openticket:transcripts","value":"v2.0.0"},
-    {"category":"openticket:last-version","key":"openticket:livestatus","value":"v2.0.0"},
-    {"category":"openticket:last-version","key":"openticket:last-version","value":"v4.0.0"}
-]

docker-compose.yml

@@ -4,6 +4,8 @@ services:
   openticket:
     build: .
     volumes:
-      - .:/app
+      - openticket:/home/container
-    environment: NODE_ENV=production
+    restart: no
-    restart: unless-stopped
+    container_name: open-ticket
+volumes:
+  openticket:

dockerfile

@@ -1,9 +1,9 @@
 # Docker File for Open Ticket v4
-# Use the official Node.js 18 image from Docker Hub
+# Use the official Node.js 20 image from Docker Hub
-FROM node:18-alpine
+FROM node:20-alpine
 
-# Set a different working directory inside the container
+# Set pterodactyl working directory inside the container
-WORKDIR /usr/src/openticket
+WORKDIR /home/container
 
 # Copy package.json and package-lock.json into the container
 COPY package*.json ./

index.js

@@ -1,53 +1,133 @@
-const fs = require("fs")
-const ts = require("typescript")
-const nodepath = require('path')
-
 /////////////// STARTUP FLAGS ///////////////
 const flags = [
+    // Edit flags here when being unable to use the flags in the command prompt.
     //PTERODACTYL PANEL
     //add startup flags here (e.g. "--no-compile") when running via the panel
 ]
 process.argv.push(...flags)
 /////////////// STARTUP FLAGS ///////////////
 
+/*
+ ██████╗ ██████╗ ███████╗███╗   ██╗    ████████╗██╗ ██████╗██╗  ██╗███████╗████████╗  
+██╔═══██╗██╔══██╗██╔════╝████╗  ██║    ╚══██╔══╝██║██╔════╝██║ ██╔╝██╔════╝╚══██╔══╝  
+██║   ██║██████╔╝█████╗  ██╔██╗ ██║       ██║   ██║██║     █████╔╝ █████╗     ██║     
+██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║       ██║   ██║██║     ██╔═██╗ ██╔══╝     ██║     
+╚██████╔╝██║     ███████╗██║ ╚████║       ██║   ██║╚██████╗██║  ██╗███████╗   ██║     
+ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝       ╚═╝   ╚═╝ ╚═════╝╚═╝  ╚═╝╚══════╝   ╚═╝     
+ v4.0.3 - Made by DJj123dj & Contributors
+
+ Discord: https://discord.dj-dj.be
+ Docs: https://otdocs.dj-dj.be
+ Support Us: https://github.com/sponsors/DJj123dj/
+ 
+ */
+///////////////////////////////////////////
+////////// COMPILATION + STARTUP //////////
+///////////////////////////////////////////
+const fs = require("fs")
+const ts = require("typescript")
+const {createHash,Hash} = require("crypto")
+const nodepath = require('path')
+
+/** ## What is this?
+ * This is a function which compares `./src/` with a hash stored in `./dist/hash.txt`.
+ * The hash is based on the modified date & file metadata of all files in `./src/`.
+ * 
+ * If the hash is different, the bot will automatically re-compile.
+ * This will help you save CPU resources because the bot shouldn't re-compile when nothing has been changed :)
+ * 
+ * @param {string} dir
+ * @param {Hash|null} upperHash
+ */
+function computeSourceHash(dir,upperHash){
+    const hash = upperHash ? upperHash : createHash("sha256")
+    const info = fs.readdirSync(dir,{withFileTypes:true})
+    
+    for (const file of info) {
+        const fullPath = nodepath.join(dir,file.name)
+        if (file.isFile() && [".js",".ts",".jsx",".tsx"].some((ext) => file.name.endsWith(ext))){
+            const statInfo = fs.statSync(fullPath)
+            //compute hash using file metadata
+            const fileInfo = `${fullPath}:${statInfo.size}:${statInfo.mtimeMs}`
+            hash.update(fileInfo)
+            
+        }else if (file.isDirectory()){
+            //recursively compute all folders
+            computeSourceHash(fullPath,hash)
+        }
+    }
+    //return when not being called recursively
+    if (!upperHash) {
+        return hash.digest("hex")
+    }
+}
+function requiresCompilation(){
+    //check hashes when not using "--compile-only" flag
+    if (process.argv.includes("--compile-only")) return true
+
+    console.log("OT: Comparing prebuilds with source...")
+    const sourceHash = computeSourceHash("./src/")
+    const pluginHash = computeSourceHash("./plugins/")
+    const hash = sourceHash+":"+pluginHash
+
+    if (fs.existsSync("./dist/hash.txt")){
+        const distHash = fs.readFileSync("./dist/hash.txt").toString()
+        if (distHash === hash) return false
+        else return true
+    }else return true
+}
+function saveNewCompilationHash(){
+    const sourceHash = computeSourceHash("./src/")
+    const pluginHash = computeSourceHash("./plugins/")
+    const hash = sourceHash+":"+pluginHash
+    fs.writeFileSync("./dist/hash.txt",hash)
+}
+
 if (!process.argv.includes("--no-compile")){
-    //REMOVE EXISTING BUILDS
+    if (requiresCompilation()){
-    console.log("OT: Removing Prebuilds...")
+        console.log("OT: Compilation Required...")
-    fs.rmSync("./dist",{recursive:true,force:true})
 
-    //COMPILE TYPESCRIPT
+        //REMOVE EXISTING BUILDS
-    console.log("OT: Compiling Typescript...")
+        console.log("OT: Removing Prebuilds...")
-    const configPath = nodepath.resolve('./tsconfig.json')
+        fs.rmSync("./dist",{recursive:true,force:true})
-    const configFile = ts.readConfigFile(configPath,ts.sys.readFile)
 
-    //check for tsconfig errors
+        //COMPILE TYPESCRIPT
-    if (configFile.error){
+        console.log("OT: Compiling Typescript...")
-        const message = ts.formatDiagnosticsWithColorAndContext([configFile.error],ts.createCompilerHost({}))
+        const configPath = nodepath.resolve('./tsconfig.json')
-        console.error(message)
+        const configFile = ts.readConfigFile(configPath,ts.sys.readFile)
-        process.exit(1)
-    }
 
-    //parse tsconfig file
+        //check for tsconfig errors
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config,ts.sys,nodepath.dirname(configPath))
+        if (configFile.error){
+            const message = ts.formatDiagnosticsWithColorAndContext([configFile.error],ts.createCompilerHost({}))
+            console.error(message)
+            process.exit(1)
+        }
 
-    //create program/compiler
+        //parse tsconfig file
-    const program = ts.createProgram({
+        const parsedConfig = ts.parseJsonConfigFileContent(configFile.config,ts.sys,nodepath.dirname(configPath))
-        rootNames:parsedConfig.fileNames,
-        options:parsedConfig.options
-    })
 
-    //emit all compiled files
+        //create program/compiler
-    const emitResult = program.emit()
+        const program = ts.createProgram({
+            rootNames:parsedConfig.fileNames,
+            options:parsedConfig.options
+        })
 
-    //print emit errors/warnings (type errors)
+        //emit all compiled files
-    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics)
+        const emitResult = program.emit()
-    const formattedDiagnostics = ts.formatDiagnosticsWithColorAndContext(allDiagnostics, ts.createCompilerHost(parsedConfig.options))
-    console.log(formattedDiagnostics)
 
-    if (emitResult.emitSkipped || allDiagnostics.find((d) => d.category == ts.DiagnosticCategory.Error || d.category == ts.DiagnosticCategory.Warning)){
+        //print emit errors/warnings (type errors)
-        console.log("OT: Compilation Failed!")
+        const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics)
-        process.exit(1)
+        const formattedDiagnostics = ts.formatDiagnosticsWithColorAndContext(allDiagnostics, ts.createCompilerHost(parsedConfig.options))
-    }
+        console.log(formattedDiagnostics)
+
+        if (emitResult.emitSkipped || allDiagnostics.find((d) => d.category == ts.DiagnosticCategory.Error || d.category == ts.DiagnosticCategory.Warning)){
+            console.log("OT: Compilation Failed!")
+            process.exit(1)
+        }
+    }else console.log("OT: No Compilation Required...")
+
+    //save new compilation hash
+    saveNewCompilationHash()
 }
 
 //START BOT

languages/arabic.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION": {
-        "otversion": "v4.0.0",
+        "otversion": "v4.0.3",
         "translators": ["palestinian"],
         "lastedited": "06/12/2024",
         "language": "Arabic",

languages/catalan.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["guillee3"],
         "lastedited":"21/08/2024",
         "language":"Catalan",

languages/custom.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["DJj123dj"],
         "lastedited":"21/08/2024",
         "language":"Custom",
@@ -13,7 +13,7 @@
             "typeWarning":"[WARNING]",
             "typeInfo":"[INFO]",
             "headerConfigChecker":"CONFIG CHECKER",
-            "headerDescription":"check for errors in you config files!",
+            "headerDescription":"check for errors in your config files!",
             "footerError":"the bot won't start until all {0}'s are fixed!",
             "footerWarning":"it's recommended to fix all {0}'s before starting!",
             "footerSupport":"SUPPORT: {0} - DOCS: {1}",

languages/czech.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["spyeye_"],
         "lastedited":"21/08/2024",
         "language":"Czech",

languages/danish.json

@@ -1,6 +1,6 @@
 {
   "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["the_gamer"],
         "lastedited":"26/09/2024",
         "language":"Danish",

languages/dutch.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["DJj123dj"],
         "lastedited":"21/08/2024",
         "language":"Dutch",

languages/english.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["DJj123dj"],
         "lastedited":"21/08/2024",
         "language":"English",
@@ -13,7 +13,7 @@
             "typeWarning":"[WARNING]",
             "typeInfo":"[INFO]",
             "headerConfigChecker":"CONFIG CHECKER",
-            "headerDescription":"check for errors in you config files!",
+            "headerDescription":"check for errors in your config files!",
             "footerError":"the bot won't start until all {0}'s are fixed!",
             "footerWarning":"it's recommended to fix all {0}'s before starting!",
             "footerSupport":"SUPPORT: {0} - DOCS: {1}",

languages/estonian.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["iamnotmega","ChatGPT"],
         "lastedited":"21/10/2024",
         "language":"Estonian",

languages/finnish.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["iamnotmega","ChatGPT"],
         "lastedited":"21/10/2024",
         "language":"Finnish",

languages/french.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["guillee3"],
         "lastedited":"04/12/2024",
         "language":"French",

languages/german.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["benzorich"],
         "lastedited":"06/10/2024",
         "language":"German",

languages/hindi.json

@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION":{
+        "otversion":"v4.0.3",
+        "translators":["an_developer"],
+        "lastedited":"14/12/2024",
+        "language":"Hindi",
+        "automated":false
+    },
+    "checker":{
+        "system":{
+            "typeError":"[गलती]",
+            "headerOpenTicket":"खुला टिकट",
+            "typeWarning":"[चेतावनी]",
+            "typeInfo":"[जानकारी]",
+            "headerConfigChecker":"कॉन्फिग चेकर",
+            "headerDescription":"अपनी कॉन्फ़िग फ़ाइलों में त्रुटियों की जाँच करें!",
+            "footerError":"जब तक सभी {0} ठीक नहीं हो जाते, बॉट प्रारंभ नहीं होगा!",
+            "footerWarning":"प्रारंभ करने से पहले सभी {0} को ठीक करने की अनुशंसा की जाती है!",
+            "footerSupport":"समर्थन: {0} - दस्तावेज़: {1}",
+            "compactInformation":"अधिक जानकारी के लिए {0} का उपयोग करें!",
+            "dataPath":"पथ",
+            "dataDocs":"डॉक्स",
+            "dataMessages":"संदेश"
+        },
+        "messages":{
+            "stringTooShort":"यह स्ट्रिंग {0} वर्णों से छोटी नहीं हो सकती!",
+            "stringTooLong":"यह स्ट्रिंग {0} वर्णों से अधिक लंबी नहीं हो सकती!",
+            "stringLengthInvalid":"यह स्ट्रिंग {0} अक्षर लंबी होनी चाहिए!",
+            "stringStartsWith":"यह स्ट्रिंग {0} से शुरू होनी चाहिए!",
+            "stringEndsWith":"इस स्ट्रिंग को {0} पर समाप्त होना चाहिए!",
+            "stringContains":"इस स्ट्रिंग में {0} होना आवश्यक है!",
+            "stringChoices":"यह स्ट्रिंग केवल निम्नलिखित मानों में से एक हो सकती है: {0}!",
+            "stringRegex":"यह स्ट्रिंग अमान्य है!",
+
+            "numberTooShort":"यह संख्या {0} वर्णों से छोटी नहीं हो सकती!",
+            "numberTooLong":"यह संख्या {0} वर्णों से अधिक लंबी नहीं हो सकती!",
+            "numberLengthInvalid":"यह संख्या {0} वर्ण लंबी होनी चाहिए!",
+            "numberTooSmall":"यह संख्या कम से कम {0} होनी चाहिए!",
+            "numberTooLarge":"यह संख्या अधिकतम {0} होनी चाहिए!",
+            "numberNotEqual":"यह संख्या {0} होनी चाहिए!",
+            "numberStep":"यह संख्या {0} का गुणज होनी चाहिए!",
+            "numberStepOffset":"यह संख्या {1} से शुरू होकर {0} का गुणज होनी चाहिए!",
+            "numberStartsWith":"यह संख्या {0} से शुरू होनी चाहिए!",
+            "numberEndsWith":"यह संख्या {0} पर समाप्त होनी चाहिए!",
+            "numberContains":"इस संख्या में {0} होना आवश्यक है!",
+            "numberChoices":"यह संख्या केवल निम्नलिखित मानों में से एक हो सकती है: {0}!",
+            "numberFloat":"यह संख्या दशमलव नहीं हो सकती!",
+            "numberNegative":"यह संख्या ऋणात्मक नहीं हो सकती!",
+            "numberPositive":"यह संख्या सकारात्मक नहीं हो सकती!",
+            "numberZero":"यह संख्या शून्य नहीं हो सकती!",
+
+            "booleanTrue":"यह बूलियन सत्य नहीं हो सकता!",
+            "booleanFalse":"यह बूलियन झूठा नहीं हो सकता!",
+
+            "arrayEmptyDisabled":"इस सरणी को खाली रहने की अनुमति नहीं है!",
+            "arrayEmptyRequired":"यह सरणी खाली होनी आवश्यक है!",
+            "arrayTooShort":"इस सरणी की लंबाई कम से कम {0} होनी चाहिए!",
+            "arrayTooLong":"इस सरणी की लंबाई अधिकतम {0} होनी चाहिए!",
+            "arrayLengthInvalid":"इस सरणी की लंबाई {0} होनी चाहिए!",
+            "arrayInvalidTypes":"इस सरणी में केवल निम्नलिखित प्रकार हो सकते हैं: {0}!",
+            "arrayDouble":"यह सरणी एक ही मान को दो बार अनुमति नहीं देती है!",
+
+            "discordInvalidId":"यह एक अमान्य कलह {0} आईडी है!",
+            "discordInvalidIdOptions":"यह एक अमान्य कलह {0} आईडी है! ",
+            "discordInvalidToken":"यह एक अमान्य कलह टोकन है (वाक्यविन्यास की दृष्टि से)!",
+            "colorInvalid":"यह अमान्य हेक्स रंग है!",
+            "emojiTooShort":"इस स्ट्रिंग में कम से कम {0} इमोजी होना आवश्यक है!",
+            "emojiTooLong":"इस स्ट्रिंग में अधिकतम {0} इमोजी होना आवश्यक है!",
+            "emojiCustom":"यह इमोजी कस्टम डिसॉर्डर इमोजी नहीं हो सकता!",
+            "emojiInvalid":"यह एक अमान्य इमोजी है!",
+            "urlInvalid":"यह यूआरएल अमान्य है!",
+            "urlInvalidHttp":"यह यूआरएल केवल https:// प्रोटोकॉल का उपयोग कर सकता है!",
+            "urlInvalidProtocol":"यह यूआरएल केवल http:// और https:// प्रोटोकॉल का उपयोग कर सकता है!",
+            "urlInvalidHostname":"इस यूआरएल में एक अस्वीकृत होस्टनाम है!",
+            "urlInvalidExtension":"इस यूआरएल में एक अमान्य एक्सटेंशन है! ",
+            "urlInvalidPath":"इस यूआरएल में एक अमान्य पथ है!",
+            "idNotUnique":"यह आईडी अद्वितीय नहीं है, इसके बजाय किसी अन्य आईडी का उपयोग करें!",
+            "idNonExistent":"आईडी {0} मौजूद नहीं है!",
+
+            "invalidType":"यह संपत्ति इस प्रकार की होनी चाहिए: {0}!",
+            "propertyMissing":"इस ऑब्जेक्ट में संपत्ति {0} गायब है!",
+            "propertyOptional":"इस ऑब्जेक्ट में संपत्ति {0} वैकल्पिक है!",
+            "objectDisabled":"यह ऑब्जेक्ट अक्षम है, इसे {0} का उपयोग करके सक्षम करें!",
+            "nullInvalid":"यह संपत्ति शून्य नहीं हो सकती!",
+            "switchInvalidType":"इसे निम्न प्रकारों में से एक होना आवश्यक है: {0}!",
+            "objectSwitchInvalid":"यह ऑब्जेक्ट निम्न प्रकारों में से एक होना चाहिए: {0}!",
+
+            "invalidLanguage":"यह एक अमान्य भाषा है!",
+            "invalidButton":"इस बटन पर कम से कम {0} या {1} होना आवश्यक है!",
+            "unusedOption":"विकल्प {0} का उपयोग कहीं भी नहीं किया जाता है!",
+            "unusedQuestion":"प्रश्न {0} का प्रयोग कहीं भी नहीं किया गया है!",
+            "dropdownOption":"ड्रॉपडाउन सक्षम पैनल में केवल 'टिकट' प्रकार के विकल्प हो सकते हैं!"
+        }
+    },
+    "actions":{
+        "buttons":{
+            "create":"विजिट टिकट",
+            "close":"टिकट बंद करें",
+            "delete":"टिकट हटाएँ",
+            "reopen":"टिकट पुनः खोलें",
+            "claim":"टिकट का दावा करें",
+            "unclaim":"लावारिस टिकट",
+            "pin":"टिकट पिन करें",
+            "unpin":"टिकट अनपिन करें",
+            "clear":"टिकट हटाएँ",
+            "helpSwitchSlash":"स्लैश कमांड देखें",
+            "helpSwitchText":"टेक्स्ट कमांड देखें",
+            "helpPage":"पेज {0}",
+            "withReason":"कारण के साथ",
+            "withoutTranscript":"प्रतिलेख के बिना"
+        },
+        "titles":{
+            "created":"टिकट बनाया गया",
+            "close":"टिकट बंद",
+            "delete":"टिकट हटा दिया गया",
+            "reopen":"टिकट पुनः खोला गया",
+            "claim":"टिकट का दावा किया गया",
+            "unclaim":"टिकट लावारिस",
+            "pin":"टिकट पिन किया गया",
+            "unpin":"टिकट अनपिन किया गया",
+            "rename":"टिकट का नाम बदला गया",
+            "move":"टिकट स्थानांतरित",
+            "add":"टिकट उपयोगकर्ता जोड़ा गया",
+            "remove":"टिकट उपयोगकर्ता हटा दिया गया",
+
+            "help":"उपलब्ध आदेश",
+            "statsReset":"आँकड़े रीसेट करें",
+            "blacklistAdd":"उपयोगकर्ता को ब्लैकलिस्ट किया गया",
+            "blacklistRemove":"उपयोगकर्ता जारी किया गया",
+            "blacklistGet":"ब्लैकलिस्टेड उपयोगकर्ता",
+            "blacklistView":"वर्तमान ब्लैकलिस्ट",
+            "blacklistAddDm":"ब्लैकलिस्ट में जोड़ा गया",
+            "blacklistRemoveDm":"काली सूची से हटाया गया",
+            "clear":"टिकट साफ़ हो गए",
+            "roles":"भूमिकाएँ अद्यतन की गईं",
+
+            "autoclose":"टिकट स्वतः बंद",
+            "autocloseEnabled":"स्वत: बंद सक्षम",
+            "autocloseDisabled":"स्वत: बंद अक्षम",
+            "autodelete":"टिकट स्वतः हटा दिया गया",
+            "autodeleteEnabled":"स्वतः हटाना सक्षम",
+            "autodeleteDisabled":"स्वतः हटाना अक्षम"
+        },
+        "descriptions":{
+            "create":"आपका टिकट बन गया है. ",
+            "close":"टिकट सफलतापूर्वक बंद कर दिया गया है!",
+            "delete":"टिकट सफलतापूर्वक हटा दिया गया है!",
+            "reopen":"टिकट सफलतापूर्वक पुनः खोल दिया गया है!",
+            "claim":"टिकट का सफलतापूर्वक दावा किया गया है!",
+            "unclaim":"टिकट सफलतापूर्वक लावारिस हो गया है!",
+            "pin":"टिकट सफलतापूर्वक पिन कर दिया गया है!",
+            "unpin":"टिकट सफलतापूर्वक अनपिन कर दिया गया है!",
+            "rename":"टिकट का नाम बदलकर सफलतापूर्वक {0} कर दिया गया है!",
+            "move":"टिकट को सफलतापूर्वक {0} पर ले जाया गया है!",
+            "add":"{0} को टिकट में सफलतापूर्वक जोड़ दिया गया है!",
+            "remove":"{0} को टिकट से सफलतापूर्वक हटा दिया गया है!",
+
+            "helpExplanation":"`<name>` => आवश्यक पैरामीटर\n",
+            "statsReset":"बॉट आँकड़े सफलतापूर्वक रीसेट कर दिए गए हैं!",
+            "statsError":"टिकट आँकड़े देखने में असमर्थ!\n",
+            "blacklistAdd":"{0} को सफलतापूर्वक काली सूची में डाल दिया गया है!",
+            "blacklistRemove":"{0} सफलतापूर्वक जारी कर दिया गया है!",
+            "blacklistGetSuccess":"{0} वर्तमान में ब्लैकलिस्टेड है!",
+            "blacklistGetEmpty":"{0} वर्तमान में काली सूची में नहीं डाला गया है!",
+            "blacklistViewEmpty":"अभी तक किसी को भी काली सूची में नहीं डाला गया है!",
+            "blacklistViewTip":"किसी उपयोगकर्ता को ब्लैकलिस्ट करने के लिए \"/ब्लैकलिस्ट ऐड\" का उपयोग करें!",
+            "clearVerify":"क्या आप वाकई एकाधिक टिकट हटाना चाहते हैं?\n",
+            "clearReady":"{0} टिकट सफलतापूर्वक हटा दिए गए हैं!",
+            "rolesEmpty":"कोई भूमिका अद्यतन नहीं की गई है!",
+
+            "autocloseLeave":"यह टिकट स्वतः बंद हो गया है क्योंकि निर्माता ने सर्वर छोड़ दिया है!",
+            "autocloseTimeout":"यह टिकट स्वतः बंद कर दिया गया है क्योंकि यह `{0}h` से अधिक समय से निष्क्रिय है!",
+            "autodeleteLeave":"यह टिकट स्वतः हटा दिया गया है क्योंकि निर्माता ने सर्वर छोड़ दिया है!",
+            "autodeleteTimeout":"यह टिकट स्वतः हटा दिया गया है क्योंकि यह `{0} दिनों` से अधिक समय से निष्क्रिय है!",
+            "autocloseEnabled":"इस टिकट में ऑटोक्लोज़ सक्षम कर दिया गया है!\n",
+            "autocloseDisabled":"इस टिकट में ऑटोक्लोज़ अक्षम कर दिया गया है!\n",
+            "autodeleteEnabled":"इस टिकट में ऑटोडिलीट सक्षम कर दिया गया है!\n",
+            "autodeleteDisabled":"इस टिकट में ऑटोडिलीट अक्षम कर दिया गया है!\n",
+
+            "ticketMessageLimit":"आप एक ही समय में केवल {0} टिकट बना सकते हैं!",
+            "ticketMessageAutoclose":"{0}घंटे तक निष्क्रिय रहने पर यह टिकट स्वतः बंद हो जाएगा!",
+            "ticketMessageAutodelete":"{0} दिनों तक निष्क्रिय रहने पर यह टिकट स्वतः हटा दिया जाएगा!",
+            "panelReady":"आप नीचे पैनल पा सकते हैं!\n"
+        },
+        "modal":{
+            "closePlaceholder":"आपने यह टिकट क्यों बंद कर दिया?",
+            "deletePlaceholder":"आपने यह टिकट क्यों हटा दिया?",
+            "reopenPlaceholder":"आपने यह टिकट दोबारा क्यों खोला?",
+            "claimPlaceholder":"आपने इस टिकट के लिए दावा क्यों किया?",
+            "unclaimPlaceholder":"आपने इस टिकट पर दावा क्यों रद्द कर दिया?",
+            "pinPlaceholder":"आपने यह टिकट पिन क्यों किया?",
+            "unpinPlaceholder":"आपने इस टिकट को अनपिन क्यों किया?"
+        },
+        "logs":{
+            "createLog":"{0} द्वारा एक नया टिकट बनाया गया!",
+            "closeLog":"यह टिकट {0} द्वारा बंद कर दिया गया है!",
+            "closeDm":"आपका टिकट हमारे सर्वर में बंद कर दिया गया है!",
+            "deleteLog":"यह टिकट {0} द्वारा हटा दिया गया है!",
+            "deleteDm":"आपका टिकट हमारे सर्वर से हटा दिया गया है!",
+            "reopenLog":"यह टिकट {0} द्वारा पुनः खोल दिया गया है!",
+            "reopenDm":"आपका टिकट हमारे सर्वर में फिर से खोल दिया गया है!",
+            "claimLog":"इस टिकट पर {0} द्वारा दावा किया गया है!",
+            "claimDm":"आपके टिकट का दावा हमारे सर्वर में कर दिया गया है!",
+            "unclaimLog":"यह टिकट {0} द्वारा लावारिस कर दिया गया है!",
+            "unclaimDm":"आपका टिकट हमारे सर्वर में लावारिस हो गया है!",
+            "pinLog":"यह टिकट {0} द्वारा पिन किया गया है!",
+            "pinDm":"आपका टिकट हमारे सर्वर में पिन कर दिया गया है!",
+            "unpinLog":"यह टिकट {0} द्वारा अनपिन कर दिया गया है!",
+            "unpinDm":"आपका टिकट हमारे सर्वर पर अनपिन कर दिया गया है!",
+            "renameLog":"इस टिकट का नाम बदलकर {1} द्वारा {0} कर दिया गया है!",
+            "renameDm":"हमारे सर्वर में आपके टिकट का नाम बदलकर {0} कर दिया गया है!",
+            "moveLog":"इस टिकट को {1} द्वारा {0} में स्थानांतरित कर दिया गया है!",
+            "moveDm":"आपका टिकट हमारे सर्वर में {0} पर स्थानांतरित कर दिया गया है!",
+            "addLog":"इस टिकट में {1} द्वारा {0} जोड़ा गया है!",
+            "addDm":"हमारे सर्वर में आपके टिकट में {0} जोड़ दिया गया है!",
+            "removeLog":"{1} द्वारा इस टिकट से {0} हटा दिया गया है!",
+            "removeDm":"हमारे सर्वर में आपके टिकट से {0} हटा दिया गया है!",
+
+            "blacklistAddLog":"{0} को {1} द्वारा काली सूची में डाल दिया गया था!",
+            "blacklistRemoveLog":"{0} को {1} द्वारा काली सूची से हटा दिया गया था!",
+            "blacklistAddDm":"आपको हमारे सर्वर में काली सूची में डाल दिया गया है!\n",
+            "blacklistRemoveDm":"आपको हमारे सर्वर में ब्लैकलिस्ट से हटा दिया गया है!\n",
+            "clearLog":"{0} टिकटें {1} द्वारा हटा दी गई हैं!"
+        }
+    },
+    "transcripts":{
+        "success":{
+            "visit":"प्रतिलेख पर जाएँ",
+            "ready":"प्रतिलेख बनाया गया",
+            "textFileDescription":"यह हटाए गए टिकट का टेक्स्ट ट्रांसक्रिप्ट है!",
+            "htmlProgress":"कृपया इस HTML प्रतिलेख के संसाधित होने तक प्रतीक्षा करें...",
+            
+            "createdChannel":"सर्वर में एक नया {0} ट्रांस्क्रिप्ट बनाया गया है!",
+            "createdCreator":"आपके एक टिकट के लिए एक नया {0} प्रतिलेख बनाया गया है!",
+            "createdParticipant":"आपके द्वारा भाग लिए गए टिकटों में से एक में एक नया {0} प्रतिलेख बनाया गया है!",
+            "createdActiveAdmin":"आपके द्वारा व्यवस्थापक के रूप में भाग लिए गए टिकटों में से एक में एक नया {0} प्रतिलेख बनाया गया है!",
+            "createdEveryAdmin":"जिन टिकटों के आप व्यवस्थापक थे उनमें से एक में एक नया {0} प्रतिलेख बनाया गया है!",
+            "createdOther":"एक नया {0} प्रतिलेख बनाया गया है!"
+        },
+        "errors":{
+            "retry":"पुन: प्रयास करें",
+            "continue":"प्रतिलेख के बिना हटाएँ",
+            "backup":"बैकअप ट्रांस्क्रिप्ट बनाएं",
+            "error":"प्रतिलेख बनाने का प्रयास करते समय कुछ गलत हो गया।\n"
+        }
+    },
+    "errors":{
+        "titles":{
+            "internalError":"आंतरिक त्रुटि",
+            "optionMissing":"आदेश विकल्प गुम है",
+            "optionInvalid":"आदेश विकल्प अमान्य",
+            "unknownCommand":"अज्ञात आदेश",
+            "noPermissions":"कोई अनुमति नहीं",
+            "unknownTicket":"अज्ञात टिकट",
+            "deprecatedTicket":"अस्वीकृत टिकट",
+            "unknownOption":"अज्ञात विकल्प",
+            "unknownPanel":"अज्ञात पैनल",
+            "notInGuild":"सर्वर में नहीं",
+            "channelRename":"चैनल का नाम बदलने में असमर्थ",
+            "busy":"टिकट व्यस्त है"
+        },
+        "descriptions":{
+            "askForInfo":"अधिक जानकारी के लिए इस बॉट के मालिक से संपर्क करें!",
+            "askForInfoResolve":"यदि कुछ प्रयासों के बाद भी यह समस्या हल नहीं होती है तो इस बॉट के मालिक से संपर्क करें।",
+            "internalError":"किसी आंतरिक त्रुटि के कारण इस {0} का उत्तर देने में विफल!",
+            "optionMissing":"इस आदेश में एक आवश्यक पैरामीटर गुम है!",
+            "optionInvalid":"इस आदेश में एक पैरामीटर अमान्य है!",
+            "optionInvalidChoose":"इनमें से चुनें",
+            "unknownCommand":"अधिक जानकारी के लिए सहायता मेनू पर जाने का प्रयास करें!",
+            "noPermissions":"आपको इस {0} का उपयोग करने की अनुमति नहीं है!",
+            "noPermissionsList":"आवश्यक अनुमतियाँ: (उनमें से एक)",
+            "noPermissionsCooldown":"आपको इस {0} का उपयोग करने की अनुमति नहीं है क्योंकि आपके पास कूलडाउन है!",
+            "noPermissionsBlacklist":"आपको इस {0} का उपयोग करने की अनुमति नहीं है क्योंकि आपको काली सूची में डाल दिया गया है!",
+            "noPermissionsLimitGlobal":"आपको टिकट बनाने की अनुमति नहीं है क्योंकि सर्वर अधिकतम टिकट सीमा तक पहुंच गया है!",
+            "noPermissionsLimitGlobalUser":"आपको टिकट बनाने की अनुमति नहीं है क्योंकि आप अधिकतम टिकट सीमा तक पहुँच गए हैं!",
+            "noPermissionsLimitOption":"आपको टिकट बनाने की अनुमति नहीं है क्योंकि सर्वर इस विकल्प के लिए अधिकतम टिकट सीमा तक पहुंच गया है!",
+            "noPermissionsLimitOptionUser":"आपको टिकट बनाने की अनुमति नहीं है क्योंकि आप इस विकल्प के लिए अधिकतम टिकट सीमा तक पहुँच गए हैं!",
+            "unknownTicket":"वैध टिकट में इस आदेश को दोबारा आज़माएँ!",
+            "deprecatedTicket":"वर्तमान चैनल वैध टिकट नहीं है! ",
+            "notInGuild":"यह {0} डीएम में काम नहीं करता! ",
+            "channelRename":"विवाद की दर सीमा के कारण, वर्तमान में बॉट के लिए चैनल का नाम बदलना असंभव है। ",
+            "channelRenameSource":"इस त्रुटि का स्रोत है: {0}",
+            "busy":"इस {0} का उपयोग करने में असमर्थ!\n"
+        },
+        "optionInvalidReasons":{
+            "stringRegex":"मान पैटर्न से मेल नहीं खाता!",
+            "stringMinLength":"मान कम से कम {0} अक्षर होना चाहिए!",
+            "stringMaxLength":"मान अधिकतम {0} वर्ण होना चाहिए!",
+            "numberInvalid":"अमान्य नंबर!",
+            "numberMin":"संख्या कम से कम {0} होनी चाहिए!",
+            "numberMax":"संख्या अधिकतम {0} होनी चाहिए!",
+            "numberDecimal":"संख्या को दशमलव होने की अनुमति नहीं है!",
+            "numberNegative":"संख्या को ऋणात्मक होने की अनुमति नहीं है!",
+            "numberPositive":"संख्या को धनात्मक होने की अनुमति नहीं है!",
+            "numberZero":"संख्या शून्य होने की अनुमति नहीं है!",
+            "channelNotFound":"चैनल ढूंढने में असमर्थ!",
+            "userNotFound":"उपयोगकर्ता ढूंढने में असमर्थ!",
+            "roleNotFound":"भूमिका ढूँढने में असमर्थ!",
+            "memberNotFound":"उपयोगकर्ता ढूंढने में असमर्थ!",
+            "mentionableNotFound":"उपयोगकर्ता या भूमिका ढूंढने में असमर्थ!",
+            "channelType":"अमान्य चैनल प्रकार!",
+            "notInGuild":"इस विकल्प के लिए आपका सर्वर में होना आवश्यक है!"
+        },
+        "permissions":{
+            "developer":"आपको बॉट का डेवलपर बनना होगा.",
+            "owner":"आपको सर्वर स्वामी होना आवश्यक है.",
+            "admin":"आपको एक सर्वर एडमिन बनना होगा.",
+            "moderator":"आपको एक मॉडरेटर बनना होगा.",
+            "support":"आपको सहायता टीम में रहना होगा.",
+            "member":"आपको सदस्य बनना होगा.",
+            "discord-administrator":"आपके पास `प्रशासक` की अनुमति होनी चाहिए।"
+        },
+        "actionInvalid":{
+            "close":"टिकट पहले ही बंद हो चुका है!",
+            "reopen":"टिकट अभी बंद नहीं हुआ है!",
+            "claim":"टिकट का दावा पहले ही हो चुका है!",
+            "unclaim":"अभी तक टिकट का दावा नहीं किया गया है!",
+            "pin":"टिकट पहले ही पिन हो चुका है!",
+            "unpin":"टिकट अभी तक पिन नहीं किया गया है!",
+            "add":"यह उपयोगकर्ता पहले से ही टिकट तक पहुंचने में सक्षम है!",
+            "remove":"इस उपयोगकर्ता को टिकट से हटाने में असमर्थ!"
+        }
+    },
+    "params":{
+        "uppercase":{
+            "ticket":"टिकट",
+            "tickets":"टिकट",
+            "reason":"कारण",
+            "creator":"निर्माता",
+            "remaining":"शेष समय",
+            "added":"जोड़ा",
+            "removed":"निकाला गया",
+            "filter":"फ़िल्टर",
+            "claimedBy":"{0} द्वारा दावा किया गया",
+            "method":"तरीका",
+            "type":"प्रकार",
+            "blacklisted":"ब्लैक लिस्ट किया",
+            "panel":"पैनल",
+            "command":"आज्ञा",
+            "system":"प्रणाली",
+            "true":"सत्य",
+            "false":"असत्य",
+            "syntax":"सिंटेक्स",
+            "originalName":"मूल नाम",
+            "newName":"नया नाम",
+            "until":"जब तक",
+            "validOptions":"वैध विकल्प",
+            "validPanels":"वैध पैनल",
+            "autoclose":"स्वतः",
+            "autodelete":"स्वतः हटाएं",
+            "startupDate":"अद्यतनीकरण शुरू करें",
+            "version":"संस्करण",
+            "name":"नाम",
+            "role":"भूमिका",
+            "status":"स्थिति",
+            "claimed":"दावा किया",
+            "pinned":"पिन की गई",
+            "creationDate":"निर्माण तिथि"
+        },
+        "lowercase":{
+            "text":"मूलपाठ",
+            "html":"एचटीएमएल",
+            "command":"आज्ञा",
+            "modal":"मॉडल",
+            "button":"बटन",
+            "dropdown":"ड्रॉप डाउन",
+            "method":"तरीका"
+        }
+    },
+    "commands":{
+        "reason":"एक वैकल्पिक कारण निर्दिष्ट करें जो लॉग में दिखाई देगा।",
+        "help":"सभी उपलब्ध आदेशों की सूची प्राप्त करें.",
+        "panel":"ड्रॉपडाउन या बटन (टिकट निर्माण के लिए) के साथ एक संदेश भेजें।",
+        "panelId":"उस पैनल का पहचानकर्ता जिसे आप स्पॉन करना चाहते हैं.",
+        "panelAutoUpdate":"क्या आप चाहते हैं कि संपादित होने पर यह पैनल स्वचालित रूप से अपडेट हो जाए?",
+        "ticket":"तुरंत टिकट बनाएं.",
+        "ticketId":"उस टिकट का पहचानकर्ता जिसे आप बनाना चाहते हैं.",
+        "close":"एक टिकट बंद करें.",
+        "delete":"एक टिकट हटाएँ.",
+        "deleteNoTranscript":"प्रतिलेख बनाए बिना इस टिकट को हटा दें।",
+        "reopen":"टिकट दोबारा खोलें.",
+        "claim":"टिकट का दावा करें.",
+        "claimUser":"इस टिकट का दावा अपने बजाय किसी और के लिए करें।",
+        "unclaim":"टिकट का दावा रद्द करें.",
+        "pin":"टिकट पिन करें.",
+        "unpin":"टिकट अनपिन करें.",
+        "move":"एक टिकट ले जाएँ.",
+        "moveId":"उस विकल्प का पहचानकर्ता जिस पर आप जाना चाहते हैं.",
+        "rename":"टिकट का नाम बदलें.",
+        "renameName":"इस टिकट का नया नाम.",
+        "add":"किसी उपयोगकर्ता को टिकट में जोड़ें.",
+        "addUser":"उपयोगकर्ता को जोड़ना है.",
+        "remove":"किसी उपयोगकर्ता को टिकट से हटाएँ.",
+        "removeUser":"उपयोगकर्ता को हटाना है.",
+        "blacklist":"टिकट ब्लैकलिस्ट प्रबंधित करें.",
+        "blacklistView":"वर्तमान ब्लैकलिस्ट की सूची देखें.",
+        "blacklistAdd":"किसी उपयोगकर्ता को काली सूची में जोड़ें.",
+        "blacklistRemove":"किसी उपयोगकर्ता को काली सूची से हटाएँ.",
+        "blacklistGet":"ब्लैकलिस्टेड उपयोगकर्ता से विवरण प्राप्त करें।",
+        "blacklistGetUser":"जिस उपयोगकर्ता से विवरण प्राप्त करना है.",
+        "stats":"बॉट, सदस्य या टिकट से आँकड़े देखें।",
+        "statsReset":"बॉट के सभी आँकड़े रीसेट करें (और शून्य से गिनती शुरू करें)।",
+        "statsGlobal":"वैश्विक आँकड़े देखें.",
+        "statsUser":"सर्वर में किसी उपयोगकर्ता के आँकड़े देखें।",
+        "statsUserUser":"देखने के लिए उपयोगकर्ता.",
+        "statsTicket":"सर्वर में टिकट के आँकड़े देखें।",
+        "statsTicketTicket":"देखने के लिए टिकट.",
+        "clear":"एक ही समय में एकाधिक टिकट हटाएँ।",
+        "clearFilter":"टिकट साफ़ करने के लिए फ़िल्टर.",
+        "clearFilters":{
+            "all":"सभी",
+            "open":"खुला",
+            "close":"बंद किया हुआ",
+            "claim":"दावा किया",
+            "unclaim":"लावारिस",
+            "pin":"पिन की गई",
+            "unpin":"अनपिन किया गया",
+            "autoclose":"स्वतः बंद"
+        },
+        "autoclose":"किसी टिकट में ऑटोक्लोज़ प्रबंधित करें.",
+        "autocloseDisable":"इस टिकट में ऑटोक्लोज़ अक्षम करें.",
+        "autocloseEnable":"इस टिकट में ऑटोक्लोज़ सक्षम करें।",
+        "autocloseEnableTime":"इस टिकट को बंद करने के लिए कितने घंटे निष्क्रिय रहने की आवश्यकता है।",
+        "autodelete":"किसी टिकट में स्वत: हटाना प्रबंधित करें.",
+        "autodeleteDisable":"इस टिकट में ऑटोडिलीट अक्षम करें।",
+        "autodeleteEnable":"इस टिकट में ऑटोडिलीट सक्षम करें।",
+        "autodeleteEnableTime":"इस टिकट को हटाने के लिए उतने दिनों की संख्या निष्क्रिय होनी चाहिए।"
+    },
+    "helpMenu":{
+        "help":"सभी उपलब्ध आदेशों की सूची प्राप्त करें.",
+        "ticket":"तुरंत टिकट बनाएं.",
+        "close":"टिकट बंद करें, इससे इस चैनल में लिखना अक्षम हो जाएगा।",
+        "delete":"टिकट हटाएं, सक्षम होने पर यह एक प्रतिलेख बनाता है।",
+        "reopen":"टिकट दोबारा खोलें, इससे इस चैनल में फिर से लिखना संभव हो जाएगा।",
+        "pin":"टिकट पिन करें. ",
+        "unpin":"टिकट अनपिन करें. ",
+        "move":"एक टिकट ले जाएँ. ",
+        "rename":"टिकट का नाम बदलें. ",
+        "claim":"टिकट का दावा करें. ",
+        "unclaim":"टिकट का दावा रद्द करें. ",
+        "add":"किसी उपयोगकर्ता को टिकट में जोड़ें. ",
+        "remove":"किसी उपयोगकर्ता को टिकट से हटाएँ. ",
+        "panel":"ड्रॉपडाउन या बटन (टिकट निर्माण के लिए) के साथ एक संदेश भेजें।",
+        "blacklistView":"वर्तमान ब्लैकलिस्ट की सूची देखें.",
+        "blacklistAdd":"किसी उपयोगकर्ता को काली सूची में जोड़ें.",
+        "blacklistRemove":"किसी उपयोगकर्ता को काली सूची से हटाएँ.",
+        "blacklistGet":"ब्लैकलिस्टेड उपयोगकर्ता से विवरण प्राप्त करें।",
+        "statsGlobal":"वैश्विक आँकड़े देखें.",
+        "statsTicket":"सर्वर में टिकट के आँकड़े देखें।",
+        "statsUser":"सर्वर में किसी उपयोगकर्ता के आँकड़े देखें।",
+        "statsReset":"बॉट के सभी आँकड़े रीसेट करें (और शून्य से गिनती शुरू करें)।",
+        "autocloseDisable":"इस टिकट में ऑटोक्लोज़ अक्षम करें.",
+        "autocloseEnable":"इस टिकट में ऑटोक्लोज़ सक्षम करें।",
+        "autodeleteDisable":"इस टिकट में ऑटोडिलीट अक्षम करें।",
+        "autodeleteEnable":"इस टिकट में ऑटोडिलीट सक्षम करें।"
+    },
+    "stats":{
+        "scopes":{
+            "global":"वैश्विक आँकड़े",
+            "system":"सिस्टम आँकड़े",
+            "user":"उपयोगकर्ता आँकड़े",
+            "ticket":"टिकट आँकड़े",
+            "participants":"प्रतिभागियों"
+        },
+        "properties":{
+            "ticketsCreated":"टिकट बनाये गये",
+            "ticketsClosed":"टिकट बंद",
+            "ticketsDeleted":"टिकटें हटा दी गईं",
+            "ticketsReopened":"टिकट पुनः खोले गए",
+            "ticketsAutoclosed":"टिकट स्वतः बंद",
+            "ticketsClaimed":"टिकट का दावा किया गया",
+            "ticketsPinned":"टिकट पिन किये गये",
+            "ticketsMoved":"टिकट ले जाया गया",
+            "usersBlacklisted":"उपयोगकर्ता ब्लैकलिस्टेड",
+            "transcriptsCreated":"प्रतिलिपियाँ बनाई गईं"
+        }
+    }
+}

languages/hungarian.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["Kornel0706"],
         "lastedited":"22/08/2024",
         "language":"Hungarian",

languages/indonesian.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["erxg"],
         "lastedited":"25/08/2024",
         "language":"Indonesian",

languages/italian.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["fraden1mvp."],
         "lastedited":"08/10/2024",
         "language":"Italian",

languages/latvian.json

@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.3",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Latvian",
+        "automated": false
+    },
+    "checker": {
+        "system": {
+            "typeError": "[KĻŪDA]",
+            "headerOpenTicket": "ATVĒRT BIĻETI",
+            "typeWarning": "[BRĪDINĀJUMS]",
+            "typeInfo": "[INFORMĀCIJA]",
+            "headerConfigChecker": "KONFIGURĀCIJAS PĀRBAUDĪTĀJS",
+            "headerDescription": "pārbaudiet kļūdas savos konfigurācijas failos!",
+            "footerError": "bots netiks startēts, kamēr visas {0} nebūs izlabotas!",
+            "footerWarning": "ieteicams izlabot visas {0} pirms startēšanas!",
+            "footerSupport": "ATBALSTS: {0} - DOKUMENTI: {1}",
+            "compactInformation": "izmantojiet {0}, lai iegūtu vairāk informācijas!",
+            "dataPath": "ceļš",
+            "dataDocs": "dokumenti",
+            "dataMessages": "ziņojums"
+        },
+        "messages": {
+            "stringTooShort": "Šis teksts nedrīkst būt īsāks par {0} rakstzīmēm!",
+            "stringTooLong": "Šis teksts nedrīkst būt garāks par {0} rakstzīmēm!",
+            "stringLengthInvalid": "Šim tekstam jābūt {0} rakstzīmju garam!",
+            "stringStartsWith": "Šim tekstam jāsākas ar {0}!",
+            "stringEndsWith": "Šim tekstam jābeidzas ar {0}!",
+            "stringContains": "Šim tekstam jāsatur {0}!",
+            "stringChoices": "Šis teksts var būt tikai viena no šīm vērtībām: {0}!",
+            "stringRegex": "Šis teksts ir nederīgs!",
+
+            "numberTooShort": "Šis skaitlis nedrīkst būt īsāks par {0} rakstzīmēm!",
+            "numberTooLong": "Šis skaitlis nedrīkst būt garāks par {0} rakstzīmēm!",
+            "numberLengthInvalid": "Šim skaitlim jābūt {0} rakstzīmju garam!",
+            "numberTooSmall": "Šim skaitlim jābūt vismaz {0}!",
+            "numberTooLarge": "Šim skaitlim jābūt ne vairāk kā {0}!",
+            "numberNotEqual": "Šim skaitlim jābūt {0}!",
+            "numberStep": "Šim skaitlim jābūt {0} reizinājumam!",
+            "numberStepOffset": "Šim skaitlim jābūt {0} reizinājumam, sākot ar {1}!",
+            "numberStartsWith": "Šim skaitlim jāsākas ar {0}!",
+            "numberEndsWith": "Šim skaitlim jābeidzas ar {0}!",
+            "numberContains": "Šim skaitlim jāsatur {0}!",
+            "numberChoices": "Šis skaitlis var būt tikai viena no šīm vērtībām: {0}!",
+            "numberFloat": "Šis skaitlis nedrīkst būt decimāldaļa!",
+            "numberNegative": "Šis skaitlis nedrīkst būt negatīvs!",
+            "numberPositive": "Šis skaitlis nedrīkst būt pozitīvs!",
+            "numberZero": "Šis skaitlis nedrīkst būt nulle!",
+
+            "booleanTrue": "Šis loģiskais mainīgais nedrīkst būt patiess!",
+            "booleanFalse": "Šis loģiskais mainīgais nedrīkst būt nepatiess!",
+
+            "arrayEmptyDisabled": "Šis masīvs nedrīkst būt tukšs!",
+            "arrayEmptyRequired": "Šim masīvam jābūt tukšam!",
+            "arrayTooShort": "Šim masīvam jābūt vismaz {0} garam!",
+            "arrayTooLong": "Šim masīvam jābūt ne garākam par {0}!",
+            "arrayLengthInvalid": "Šim masīvam jābūt {0} garam!",
+            "arrayInvalidTypes": "Šis masīvs var saturēt tikai šādus tipus: {0}!",
+            "arrayDouble": "Šis masīvs neatļauj vienādas vērtības divreiz!",
+
+            "discordInvalidId": "Šis ir nederīgs Discord {0} ID!",
+            "discordInvalidIdOptions": "Šis ir nederīgs Discord {0} ID! Jūs varat izmantot arī kādu no šiem: {1}!",
+            "discordInvalidToken": "Šis ir nederīgs Discord tokens (sintaktiski)!",
+            "colorInvalid": "Šī ir nederīga heksadecimālā krāsa!",
+            "emojiTooShort": "Šim tekstam jābūt vismaz {0} emocijzīmēm!",
+            "emojiTooLong": "Šim tekstam jābūt ne vairāk kā {0} emocijzīmēm!",
+            "emojiCustom": "Šī emocijzīme nedrīkst būt pielāgota Discord emocijzīme!",
+            "emojiInvalid": "Šī ir nederīga emocijzīme!",
+            "urlInvalid": "Šī URL ir nederīga!",
+            "urlInvalidHttp": "Šī URL var izmantot tikai https:// protokolu!",
+            "urlInvalidProtocol": "Šī URL var izmantot tikai http:// un https:// protokolus!",
+            "urlInvalidHostname": "Šai URL ir neatļauts resursdatora nosaukums!",
+            "urlInvalidExtension": "Šai URL ir nederīgs paplašinājums! Izvēlieties starp: {0}!",
+            "urlInvalidPath": "Šai URL ir nederīgs ceļš!",
+            "idNotUnique": "Šis ID nav unikāls, izmantojiet citu ID!",
+            "idNonExistent": "ID {0} neeksistē!",
+
+            "invalidType": "Šai īpašībai jābūt tipam: {0}!",
+            "propertyMissing": "Īpašība {0} trūkst šajā objektā!",
+            "propertyOptional": "Īpašība {0} šajā objektā ir izvēles!",
+            "objectDisabled": "Šis objekts ir atspējots, aktivizējiet to, izmantojot {0}!",
+            "nullInvalid": "Šī īpašība nedrīkst būt null!",
+            "switchInvalidType": "Tam jābūt vienam no šiem tipiem: {0}!",
+            "objectSwitchInvalid": "Šim objektam jābūt vienam no šiem tipiem: {0}!",
+
+            "invalidLanguage": "Šī ir nederīga valoda!",
+            "invalidButton": "Šai pogai jābūt vismaz {0} vai {1}!",
+            "unusedOption": "Opcija {0} nekur netiek izmantota!",
+            "unusedQuestion": "Jautājums {0} nekur netiek izmantots!",
+            "dropdownOption": "Panelim ar iespējotu izvēlni var būt tikai 'ticket' tipa opcijas!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Apmeklēt biļeti",
+            "close": "Aizvērt biļeti",
+            "delete": "Dzēst biļeti",
+            "reopen": "Atvērt biļeti no jauna",
+            "claim": "Pieprasīt biļeti",
+            "unclaim": "Atcelt biļetes pieprasījumu",
+            "pin": "Piespraust biļeti",
+            "unpin": "Atspraust biļeti",
+            "clear": "Dzēst biļetes",
+            "helpSwitchSlash": "Skatīt slīpsvītras komandas",
+            "helpSwitchText": "Skatīt teksta komandas",
+            "helpPage": "Lapa {0}",
+            "withReason": "Ar iemeslu",
+            "withoutTranscript": "Bez transkripta"
+        },
+        "titles": {
+            "created": "Biļete izveidota",
+            "close": "Biļete aizvērta",
+            "delete": "Biļete dzēsta",
+            "reopen": "Biļete atkal atvērta",
+            "claim": "Biļete pieprasīta",
+            "unclaim": "Biļetes pieprasījums atcelts",
+            "pin": "Biļete piesprausta",
+            "unpin": "Biļete atsprausta",
+            "rename": "Biļete pārdēvēta",
+            "move": "Biļete pārvietota",
+            "add": "Lietotājs pievienots biļetei",
+            "remove": "Lietotājs noņemts no biļetes",
+
+            "help": "Pieejamās komandas",
+            "statsReset": "Atiestatīt statistiku",
+            "blacklistAdd": "Lietotājs pievienots melnajam sarakstam",
+            "blacklistRemove": "Lietotājs atbrīvots",
+            "blacklistGet": "Melnajā sarakstā esošs lietotājs",
+            "blacklistView": "Pašreizējais melnais saraksts",
+            "blacklistAddDm": "Pievienots melnajam sarakstam",
+            "blacklistRemoveDm": "Noņemts no melnā saraksta",
+            "clear": "Biļetes izdzēstas",
+            "roles": "Lomas atjauninātas",
+
+            "autoclose": "Biļete automātiski aizvērta",
+            "autocloseEnabled": "Automātiskā aizvēršana ieslēgta",
+            "autocloseDisabled": "Automātiskā aizvēršana izslēgta",
+            "autodelete": "Biļete automātiski dzēsta",
+            "autodeleteEnabled": "Automātiskā dzēšana ieslēgta",
+            "autodeleteDisabled": "Automātiskā dzēšana izslēgta"
+        },
+        "descriptions": {
+            "create": "Jūsu biļete ir izveidota. Noklikšķiniet uz pogas zemāk, lai tai piekļūtu!",
+            "close": "Biļete ir veiksmīgi aizvērta!",
+            "delete": "Biļete ir veiksmīgi dzēsta!",
+            "reopen": "Biļete ir veiksmīgi atkal atvērta!",
+            "claim": "Biļete ir veiksmīgi pieprasīta!",
+            "unclaim": "Biļetes pieprasījums ir veiksmīgi atcelts!",
+            "pin": "Biļete ir veiksmīgi piesprausta!",
+            "unpin": "Biļete ir veiksmīgi atsprausta!",
+            "rename": "Biļete ir veiksmīgi pārdēvēta par {0}!",
+            "move": "Biļete ir veiksmīgi pārvietota uz {0}!",
+            "add": "{0} ir veiksmīgi pievienots biļetei!",
+            "remove": "{0} ir veiksmīgi noņemts no biļetes!",
+
+            "helpExplanation": "`<nosaukums>` => obligāts parametrs\n`[nosaukums]` => izvēles parametrs",
+            "statsReset": "Bota statistika ir veiksmīgi atiestatīta!",
+            "statsError": "Nevar skatīt biļešu statistiku!\n{0} nav biļete!",
+            "blacklistAdd": "{0} ir veiksmīgi pievienots melnajam sarakstam!",
+            "blacklistRemove": "{0} ir veiksmīgi atbrīvots!",
+            "blacklistGetSuccess": "{0} pašlaik ir melnajā sarakstā!",
+            "blacklistGetEmpty": "{0} pašlaik nav melnajā sarakstā!",
+            "blacklistViewEmpty": "Vēl neviens nav melnajā sarakstā!",
+            "blacklistViewTip": "Izmantojiet \"/blacklist add\", lai pievienotu lietotāju melnajam sarakstam!",
+            "clearVerify": "Vai esat pārliecināts, ka vēlaties dzēst vairākas biļetes?\nŠo darbību nevar atsaukt!",
+            "clearReady": "{0} biļetes ir veiksmīgi dzēstas!",
+            "rolesEmpty": "Neviena loma nav atjaunināta!",
+
+            "autocloseLeave": "Šī biļete tika automātiski aizvērta, jo izveidotājs pameta serveri!",
+            "autocloseTimeout": "Šī biļete tika automātiski aizvērta, jo tā bija neaktīva ilgāk par `{0}h`!",
+            "autodeleteLeave": "Šī biļete tika automātiski dzēsta, jo izveidotājs pameta serveri!",
+            "autodeleteTimeout": "Šī biļete tika automātiski dzēsta, jo tā bija neaktīva ilgāk par `{0} dienām`!",
+            "autocloseEnabled": "Automātiskā aizvēršana ir ieslēgta šai biļetei!\nTā tiks aizvērta, ja būs neaktīva ilgāk par `{0}h`!",
+            "autocloseDisabled": "Automātiskā aizvēršana ir izslēgta šai biļetei!\nTā vairs netiks automātiski aizvērta!",
+            "autodeleteEnabled": "Automātiskā dzēšana ir ieslēgta šai biļetei!\nTā tiks dzēsta, ja būs neaktīva ilgāk par `{0} dienām`!",
+            "autodeleteDisabled": "Automātiskā dzēšana ir izslēgta šai biļetei!\nTā vairs netiks automātiski dzēsta!",
+
+            "ticketMessageLimit": "Jūs varat izveidot tikai {0} biļeti(-es) vienlaikus!",
+            "ticketMessageAutoclose": "Šī biļete tiks automātiski aizvērta, ja būs neaktīva {0}h!",
+            "ticketMessageAutodelete": "Šī biļete tiks automātiski dzēsta, ja būs neaktīva {0} dienas!",
+            "panelReady": "Paneli var atrast zemāk!\nŠo ziņojumu tagad var dzēst!"
+        },
+        "modal": {
+            "closePlaceholder": "Kāpēc jūs aizvērāt šo biļeti?",
+            "deletePlaceholder": "Kāpēc jūs dzēsāt šo biļeti?",
+            "reopenPlaceholder": "Kāpēc jūs atkal atvērāt šo biļeti?",
+            "claimPlaceholder": "Kāpēc jūs pieprasījāt šo biļeti?",
+            "unclaimPlaceholder": "Kāpēc jūs atcēlāt šīs biļetes pieprasījumu?",
+            "pinPlaceholder": "Kāpēc jūs piespraudāt šo biļeti?",
+            "unpinPlaceholder": "Kāpēc jūs atspraudāt šo biļeti?"
+        },
+        "logs": {
+            "createLog": "Jauna biļete tika izveidota no {0}!",
+            "closeLog": "Šī biļete tika aizvērta no {0}!",
+            "closeDm": "Jūsu biļete tika aizvērta mūsu serverī!",
+            "deleteLog": "Šī biļete tika dzēsta no {0}!",
+            "deleteDm": "Jūsu biļete tika dzēsta mūsu serverī!",
+            "reopenLog": "Šī biļete tika atkal atvērta no {0}!",
+            "reopenDm": "Jūsu biļete tika atkal atvērta mūsu serverī!",
+            "claimLog": "Šī biļete tika pieprasīta no {0}!",
+            "claimDm": "Jūsu biļete tika pieprasīta mūsu serverī!",
+            "unclaimLog": "Šīs biļetes pieprasījums tika atcelts no {0}!",
+            "unclaimDm": "Jūsu biļetes pieprasījums tika atcelts mūsu serverī!",
+            "pinLog": "Šī biļete tika piesprausta no {0}!",
+            "pinDm": "Jūsu biļete tika piesprausta mūsu serverī!",
+            "unpinLog": "Šī biļete tika atsprausta no {0}!",
+            "unpinDm": "Jūsu biļete tika atsprausta mūsu serverī!",
+            "renameLog": "Šī biļete tika pārdēvēta par {0} no {1}!",
+            "renameDm": "Jūsu biļete tika pārdēvēta par {0} mūsu serverī!",
+            "moveLog": "Šī biļete tika pārvietota uz {0} no {1}!",
+            "moveDm": "Jūsu biļete tika pārvietota uz {0} mūsu serverī!",
+            "addLog": "{0} tika pievienots šai biļetei no {1}!",
+            "addDm": "{0} tika pievienots jūsu biļetei mūsu serverī!",
+            "removeLog": "{0} tika noņemts no šīs biļetes no {1}!",
+            "removeDm": "{0} tika noņemts no jūsu biļetes mūsu serverī!",
+
+            "blacklistAddLog": "{0} tika pievienots melnajam sarakstam no {1}!",
+            "blacklistRemoveLog": "{0} tika noņemts no melnā saraksta no {1}!",
+            "blacklistAddDm": "Jūs esat pievienots melnajam sarakstam mūsu serverī!\nNo šī brīža jūs nevarat izveidot biļeti!",
+            "blacklistRemoveDm": "Jūs esat noņemts no melnā saraksta mūsu serverī!\nTagad jūs atkal varat izveidot biļetes!",
+            "clearLog": "{0} biļetes tika dzēstas no {1}!"
+        }
+    },
+"transcripts": {
+        "success": {
+            "visit": "Apmeklēt transkriptu",
+            "ready": "Transkripts izveidots",
+            "textFileDescription": "Šis ir dzēstas biļetes teksta transkripts!",
+            "htmlProgress": "Lūdzu, uzgaidiet, kamēr šis HTML transkripts tiek apstrādāts...",
+
+            "createdChannel": "Jauns {0} transkripts tika izveidots serverī!",
+            "createdCreator": "Jauns {0} transkripts tika izveidots vienai no jūsu biļetēm!",
+            "createdParticipant": "Jauns {0} transkripts tika izveidots vienā no biļetēm, kurā jūs piedalījāties!",
+            "createdActiveAdmin": "Jauns {0} transkripts tika izveidots vienā no biļetēm, kurā jūs piedalījāties kā administrators!",
+            "createdEveryAdmin": "Jauns {0} transkripts tika izveidots vienā no biļetēm, kurā jūs bijāt administrators!",
+            "createdOther": "Jauns {0} transkripts tika izveidots!"
+        },
+        "errors": {
+            "retry": "Mēģināt vēlreiz",
+            "continue": "Dzēst bez transkripta",
+            "backup": "Izveidot rezerves transkriptu",
+            "error": "Kaut kas nogāja greizi, mēģinot izveidot transkriptu.\nKo jūs vēlaties darīt?\n\nŠī biļete netiks dzēsta, kamēr jūs nenoklikšķināsiet uz vienas no šīm pogām."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Iekšēja kļūda",
+            "optionMissing": "Trūkst komandas opcijas",
+            "optionInvalid": "Nederīga komandas opcija",
+            "unknownCommand": "Nezināma komanda",
+            "noPermissions": "Nav atļauju",
+            "unknownTicket": "Nezināma biļete",
+            "deprecatedTicket": "Novecojusi biļete",
+            "unknownOption": "Nezināma opcija",
+            "unknownPanel": "Nezināms panelis",
+            "notInGuild": "Nav serverī",
+            "channelRename": "Nevar pārdēvēt kanālu",
+            "busy": "Biļete ir aizņemta"
+        },
+        "descriptions": {
+            "askForInfo": "Sazinieties ar šī bota īpašnieku, lai iegūtu plašāku informāciju!",
+            "askForInfoResolve": "Sazinieties ar bota īpašnieku, ja šī problēma neatrisinās pēc dažiem mēģinājumiem.",
+            "internalError": "Neizdevās atbildēt uz šo {0} iekšējas kļūdas dēļ!",
+            "optionMissing": "Šai komandai trūkst obligāta parametra!",
+            "optionInvalid": "Šīs komandas parametrs ir nederīgs!",
+            "optionInvalidChoose": "Izvēlieties starp",
+            "unknownCommand": "Mēģiniet apmeklēt palīdzības izvēlni, lai iegūtu vairāk informācijas!",
+            "noPermissions": "Jums nav atļauts izmantot šo {0}!",
+            "noPermissionsList": "Nepieciešamās atļaujas: (viena no tām)",
+            "noPermissionsCooldown": "Jums nav atļauts izmantot šo {0}, jo jums ir atpūtas periods!",
+            "noPermissionsBlacklist": "Jums nav atļauts izmantot šo {0}, jo esat melnajā sarakstā!",
+            "noPermissionsLimitGlobal": "Jūs nevarat izveidot biļeti, jo serveris ir sasniedzis maksimālo biļešu skaitu!",
+            "noPermissionsLimitGlobalUser": "Jūs nevarat izveidot biļeti, jo esat sasniedzis maksimālo biļešu skaitu!",
+            "noPermissionsLimitOption": "Jūs nevarat izveidot biļeti, jo serveris ir sasniedzis maksimālo biļešu skaitu šai opcijai!",
+            "noPermissionsLimitOptionUser": "Jūs nevarat izveidot biļeti, jo esat sasniedzis maksimālo biļešu skaitu šai opcijai!",
+            "unknownTicket": "Mēģiniet vēlreiz izmantot šo komandu derīgā biļetē!",
+            "deprecatedTicket": "Pašreizējais kanāls nav derīga biļete! Tas varētu būt biļete no vecas Open Ticket versijas!",
+            "notInGuild": "Šis {0} nedarbojas DM! Lūdzu, mēģiniet vēlreiz serverī!",
+            "channelRename": "Discord ierobežojumu dēļ bots pašlaik nevar pārdēvēt kanālu. Kanāls tiks automātiski pārdēvēts 10 minūšu laikā, ja bots netiks restartēts.",
+            "channelRenameSource": "Šīs kļūdas avots ir: {0}",
+            "busy": "Nevar izmantot šo {0}!\nBiļete pašlaik tiek apstrādāta ar botu.\n\nLūdzu, mēģiniet vēlreiz pēc dažām sekundēm!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Vērtība neatbilst šablonam!",
+            "stringMinLength": "Vērtībai jābūt vismaz {0} rakstzīmēm!",
+            "stringMaxLength": "Vērtībai jābūt ne vairāk kā {0} rakstzīmēm!",
+            "numberInvalid": "Nederīgs skaitlis!",
+            "numberMin": "Skaitlim jābūt vismaz {0}!",
+            "numberMax": "Skaitlim jābūt ne vairāk kā {0}!",
+            "numberDecimal": "Skaitlis nedrīkst būt decimāldaļa!",
+            "numberNegative": "Skaitlis nedrīkst būt negatīvs!",
+            "numberPositive": "Skaitlis nedrīkst būt pozitīvs!",
+            "numberZero": "Skaitlis nedrīkst būt nulle!",
+            "channelNotFound": "Nevar atrast kanālu!",
+            "userNotFound": "Nevar atrast lietotāju!",
+            "roleNotFound": "Nevar atrast lomu!",
+            "memberNotFound": "Nevar atrast lietotāju!",
+            "mentionableNotFound": "Nevar atrast lietotāju vai lomu!",
+            "channelType": "Nederīgs kanāla tips!",
+            "notInGuild": "Šai opcijai jābūt serverī!"
+        },
+        "permissions": {
+            "developer": "Jums jābūt bota izstrādātājam.",
+            "owner": "Jums jābūt servera īpašniekam.",
+            "admin": "Jums jābūt servera administratoram.",
+            "moderator": "Jums jābūt moderatoram.",
+            "support": "Jums jābūt atbalsta komandā.",
+            "member": "Jums jābūt dalībniekam.",
+            "discord-administrator": "Jums jābūt `ADMINISTRATOR` atļaujai."
+        },
+        "actionInvalid": {
+            "close": "Biļete jau ir aizvērta!",
+            "reopen": "Biļete vēl nav aizvērta!",
+            "claim": "Biļete jau ir pieprasīta!",
+            "unclaim": "Biļete vēl nav pieprasīta!",
+            "pin": "Biļete jau ir piesprausta!",
+            "unpin": "Biļete nav piesprausta!",
+            "add": "Šis lietotājs jau var piekļūt biļetei!",
+            "remove": "Nevar noņemt šo lietotāju no biļetes!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Biļete",
+            "tickets": "Biļetes",
+            "reason": "Iemesls",
+            "creator": "Izveidotājs",
+            "remaining": "Atlikušais laiks",
+            "added": "Pievienots",
+            "removed": "Noņemts",
+            "filter": "Filtrs",
+            "claimedBy": "Pieprasījis {0}",
+            "method": "Metode",
+            "type": "Tips",
+            "blacklisted": "Melnajā sarakstā",
+            "panel": "Panelis",
+            "command": "Komanda",
+            "system": "Sistēma",
+            "true": "Patiess",
+            "false": "Nepatiess",
+            "syntax": "Sintakse",
+            "originalName": "Sākotnējais nosaukums",
+            "newName": "Jaunais nosaukums",
+            "until": "Līdz",
+            "validOptions": "Derīgas opcijas",
+            "validPanels": "Derīgi paneļi",
+            "autoclose": "Automātiskā aizvēršana",
+            "autodelete": "Automātiskā dzēšana",
+            "startupDate": "Startēšanas datums",
+            "version": "Versija",
+            "name": "Nosaukums",
+            "role": "Loma",
+            "status": "Statuss",
+            "claimed": "Pieprasīts",
+            "pinned": "Piesprausts",
+            "creationDate": "Izveidošanas datums"
+        },
+        "lowercase": {
+            "text": "teksts",
+            "html": "html",
+            "command": "komanda",
+            "modal": "modāls",
+            "button": "poga",
+            "dropdown": "izvēlne",
+            "method": "metode"
+        }
+    },
+    "commands": {
+        "reason": "Norādiet izvēles iemeslu, kas būs redzams žurnālos.",
+        "help": "Iegūstiet visu pieejamo komandu sarakstu.",
+        "panel": "Izveidojiet ziņojumu ar izvēlni vai pogām (biļešu izveidei).",
+        "panelId": "Paneļa identifikators, kuru vēlaties izveidot.",
+        "panelAutoUpdate": "Vai vēlaties, lai šis panelis automātiski atjauninātos, kad tas tiek rediģēts?",
+        "ticket": "Nekavējoties izveidojiet biļeti.",
+        "ticketId": "Biļetes identifikators, kuru vēlaties izveidot.",
+        "close": "Aizveriet biļeti.",
+        "delete": "Dzēsiet biļeti.",
+        "deleteNoTranscript": "Dzēsiet šo biļeti, neizveidojot transkriptu.",
+        "reopen": "Atveriet biļeti no jauna.",
+        "claim": "Pieprasiet biļeti.",
+        "claimUser": "Pieprasiet šo biļeti kādam citam, nevis sev.",
+        "unclaim": "Atceliet biļetes pieprasījumu.",
+        "pin": "Piespraudiet biļeti.",
+        "unpin": "Atspraudiet biļeti.",
+        "move": "Pārvietojiet biļeti.",
+        "moveId": "Opcijas identifikators, uz kuru vēlaties pārvietot.",
+        "rename": "Pārdēvējiet biļeti.",
+        "renameName": "Jaunais nosaukums šai biļetei.",
+        "add": "Pievienojiet lietotāju biļetei.",
+        "addUser": "Lietotājs, kuru pievienot.",
+        "remove": "Noņemiet lietotāju no biļetes.",
+        "removeUser": "Lietotājs, kuru noņemt.",
+        "blacklist": "Pārvaldiet biļešu melno sarakstu.",
+        "blacklistView": "Skatiet pašreizējā melnā saraksta sarakstu.",
+        "blacklistAdd": "Pievienojiet lietotāju melnajam sarakstam.",
+        "blacklistRemove": "Noņemiet lietotāju no melnā saraksta.",
+        "blacklistGet": "Iegūstiet informāciju par melnajā sarakstā esošu lietotāju.",
+        "blacklistGetUser": "Lietotājs, par kuru iegūt informāciju.",
+        "stats": "Skatiet statistiku no bota, dalībnieka vai biļetes.",
+        "statsReset": "Atiestatiet visu bota statistiku (un sāciet skaitīt no nulles).",
+        "statsGlobal": "Skatiet globālo statistiku.",
+        "statsUser": "Skatiet lietotāja statistiku serverī.",
+        "statsUserUser": "Lietotājs, kuru skatīt.",
+        "statsTicket": "Skatiet biļetes statistiku serverī.",
+        "statsTicketTicket": "Biļete, kuru skatīt.",
+        "clear": "Dzēsiet vairākas biļetes vienlaikus.",
+        "clearFilter": "Filtrs biļešu dzēšanai.",
+        "clearFilters": {
+            "all": "Visas",
+            "open": "Atvērtas",
+            "close": "Aizvērtas",
+            "claim": "Pieprasītas",
+            "unclaim": "Nepieprasītas",
+            "pin": "Piespraustas",
+            "unpin": "Atspraustas",
+            "autoclose": "Automātiski aizvērtas"
+        },
+        "autoclose": "Pārvaldiet automātisko aizvēršanu biļetē.",
+        "autocloseDisable": "Atspējojiet automātisko aizvēršanu šai biļetei.",
+        "autocloseEnable": "Ieslēdziet automātisko aizvēršanu šai biļetei.",
+        "autocloseEnableTime": "Stundu skaits, cik ilgi biļetei jābūt neaktīvai, lai to aizvērtu.",
+        "autodelete": "Pārvaldiet automātisko dzēšanu biļetē.",
+        "autodeleteDisable": "Atspējojiet automātisko dzēšanu šai biļetei.",
+        "autodeleteEnable": "Ieslēdziet automātisko dzēšanu šai biļetei.",
+        "autodeleteEnableTime": "Dienu skaits, cik ilgi biļetei jābūt neaktīvai, lai to dzēstu."
+    },
+    "helpMenu": {
+        "help": "Iegūstiet visu pieejamo komandu sarakstu.",
+        "ticket": "Nekavējoties izveidojiet biļeti.",
+        "close": "Aizveriet biļeti, tas atspējo rakstīšanu šajā kanālā.",
+        "delete": "Dzēsiet biļeti, tas izveido transkriptu, ja ir iespējots.",
+        "reopen": "Atveriet biļeti no jauna, tas atkal iespējo rakstīšanu šajā kanālā.",
+        "pin": "Piespraudiet biļeti. Tas pārvietos biļeti uz augšu un pievienos '📌' emocijzīmi nosaukumam.",
+        "unpin": "Atspraudiet biļeti. Biļete paliks savā pozīcijā, bet zaudēs '📌' emocijzīmi.",
+        "move": "Pārvietojiet biļeti. Tas mainīs šīs biļetes tipu.",
+        "rename": "Pārdēvējiet biļeti. Tas mainīs šīs biļetes kanāla nosaukumu.",
+        "claim": "Pieprasiet biļeti. Ar to jūs varat informēt savu komandu, ka jūs apstrādājat šo biļeti.",
+        "unclaim": "Atceliet biļetes pieprasījumu. Ar to jūs varat informēt savu komandu, ka šī biļete atkal ir brīva.",
+        "add": "Pievienojiet lietotāju biļetei. Tas ļaus lietotājam lasīt un rakstīt šajā biļetē.",
+        "remove": "Noņemiet lietotāju no biļetes. Tas atņems lietotājam iespēju lasīt un rakstīt šajā biļetē.",
+        "panel": "Izveidojiet ziņojumu ar izvēlni vai pogām (biļešu izveidei).",
+        "blacklistView": "Skatiet pašreizējā melnā saraksta sarakstu.",
+        "blacklistAdd": "Pievienojiet lietotāju melnajam sarakstam.",
+        "blacklistRemove": "Noņemiet lietotāju no melnā saraksta.",
+        "blacklistGet": "Iegūstiet informāciju par melnajā sarakstā esošu lietotāju.",
+        "statsGlobal": "Skatiet globālo statistiku.",
+        "statsTicket": "Skatiet biļetes statistiku serverī.",
+        "statsUser": "Skatiet lietotāja statistiku serverī.",
+        "statsReset": "Atiestatiet visu bota statistiku (un sāciet skaitīt no nulles).",
+        "autocloseDisable": "Atspējojiet automātisko aizvēršanu šai biļetei.",
+        "autocloseEnable": "Ieslēdziet automātisko aizvēršanu šai biļetei.",
+        "autodeleteDisable": "Atspējojiet automātisko dzēšanu šai biļetei.",
+        "autodeleteEnable": "Ieslēdziet automātisko dzēšanu šai biļetei."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Globālā statistika",
+            "system": "Sistēmas statistika",
+            "user": "Lietotāja statistika",
+            "ticket": "Biļešu statistika",
+            "participants": "Dalībnieki"
+        },
+        "properties": {
+            "ticketsCreated": "Izveidotās biļetes",
+            "ticketsClosed": "Aizvērtās biļetes",
+            "ticketsDeleted": "Dzēstās biļetes",
+            "ticketsReopened": "Atkal atvērtās biļetes",
+            "ticketsAutoclosed": "Automātiski aizvērtās biļetes",
+            "ticketsClaimed": "Pieprasītās biļetes",
+            "ticketsPinned": "Piespraustās biļetes",
+            "ticketsMoved": "Pārvietotās biļetes",
+            "usersBlacklisted": "Melnajā sarakstā esošie lietotāji",
+            "transcriptsCreated": "Izveidotie transkripti"
+        }
+    }
+}

languages/lithuanian.json

@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION":{
+        "otversion":"v4.0.3",
+        "translators":["TsgIndrius"],
+        "lastedited":"26/01/2025",
+        "language":"Lithuanian",
+        "automated":false
+    },
+    "checker":{
+        "system":{
+            "typeError":"[KLAIDA]",
+            "headerOpenTicket":"Atidaryti Bilietą",
+            "typeWarning":"[Įspėjimas]",
+            "typeInfo":"[INFORMACIJA]",
+            "headerConfigChecker":"KONFIGŪROS PATIKRINIMAS",
+            "headerDescription":"pažiūrėk klaidą savo konfigūracijos faile!",
+            "footerError":"Bot'as negali pastartuoti kol visi {0}' nebus sutvarkyti!",
+            "footerWarning":"Rekomenduojama sutvarkyti visus {0}' prieš paleidžiant bot'a!",
+            "footerSupport":"PAGALBA: {0} - DOCS: {1}",
+            "compactInformation":"NAUDOK {0} DĖL IŠSAMESNĖS INFORMACIJOS!",
+            "dataPath":"path",
+            "dataDocs":"docs",
+            "dataMessages":"pranešimas"
+        },
+        "messages":{
+            "stringTooShort":"Ši eilutė negali būti trumpesnė nei {0} raidžių!",
+            "stringTooLong":"Ši eilutė negali būti ilgesnė nei {0} raidžių!",
+            "stringLengthInvalid":"Šita eilutė turi būti ilgesnė negu {0} raidžių ilgio!",
+            "stringStartsWith":"Šita eilutė turi prasidėti su {0}!",
+            "stringEndsWith":"Ši eilutė turi baigtis su  {0}!",
+            "stringContains":"Šita eilutė turi turėti {0}!",
+            "stringChoices":"Ši eilutė gali būti tik viena iš šių pasirinkimų: {0}!",
+            "stringRegex":"Šita eilutė nėra teisinga!",
+
+            "numberTooShort":"Šis skaičius negali būti trumpesnis nei {0} raidžių!",
+            "numberTooLong":"Šis skaičius negali būti ilgesnis nei {0} raidžių!",
+            "numberLengthInvalid":"Šis skaičius turi būti {0} raidžių ilgio!",
+            "numberTooSmall":"Šis skaičius turi būti bent {0}!",
+            "numberTooLarge":"Šis skaičius turi būti ne daugiau negu {0}!",
+            "numberNotEqual":"Šis skaičius turi būti {0}!",
+            "numberStep":"Šis skaičius turi būti kartotinis {0}!",
+            "numberStepOffset":"Šis skaičius turi būti kartotinis {0} pradedant nuo {1}!",
+            "numberStartsWith":"Šitas skaičius turi pradėti nuo {0}!",
+            "numberEndsWith":"Šitas numeris turi baigtis su {0}!",
+            "numberContains":"Šitas skaičius turi turėti {0}!",
+            "numberChoices":"Šitas skaičius gali būti tik vienas iš šių pasirinkimų: {0}!",
+            "numberFloat":"Šis skaičius negali būti dešimtainis!",
+            "numberNegative":"Šitas numeris negali būti neigiamas!",
+            "numberPositive":"Šitas numeris negali būti teigiamas!",
+            "numberZero":"Šitas numeris negali būti nulinis!",
+
+            "booleanTrue":"Šis boolean negali būti tiesa!",
+            "booleanFalse":"Šis boolean negali būti neteisingas!",
+
+            "arrayEmptyDisabled":"Šis array negali būti tuščias!",
+            "arrayEmptyRequired":"Šis array turi būti tuščias!",
+            "arrayTooShort":"Šis array turi būti bent ilgesnis  negu {0}!",
+            "arrayTooLong":"Šitas array turi būti trumpesnis negu {0}!",
+            "arrayLengthInvalid":"Šio array ilgis turi būti {0}!",
+            "arrayInvalidTypes":"Šiame array gali būti tik šie tipai: {0}!",
+            "arrayDouble":"Šis array neleidžia tureti tos pačios reikšmės du kartus!",
+
+            "discordInvalidId":"Šitas neteisingas discord'o {0} ID!",
+            "discordInvalidIdOptions":"Tai neteisingas discord {0} ID! Taip pat galite naudoti vieną iš šių: {1}!",
+            "discordInvalidToken":"Šitas Token yra neteisingas prašyčiau idėti teisinga Token!",
+            "colorInvalid":"Tai netinkama šešioliktainė spalva!",
+            "emojiTooShort":"Ši eilutė turi turėti bent {0} jaustukų!",
+            "emojiTooLong":"Šią eilutę reikia turėti maziau negu {0} jaustukų!",
+            "emojiCustom":"Šitas jaustukas negali būti nuosavas!",
+            "emojiInvalid":"Šitas jaustukas netinkamas!",
+            "urlInvalid":"Šitas linkas neveikiantis!",
+            "urlInvalidHttp":"Šitas linkas turi naudoti https:// protocol!",
+            "urlInvalidProtocol":"Šitas linkas turi naudoti http:// & https:// protocols!",
+            "urlInvalidHostname":"Šio linko serverio pavadinimas neleidžiamas!",
+            "urlInvalidExtension":"Šiame URL yra netinkamas plėtinys! Pasirinkite tarp: {0}!",
+            "urlInvalidPath":"Šiame URL yra netinkamas kelias!",
+            "idNotUnique":"Šis ID nėra unikalus, naudokite kitą ID!",
+            "idNonExistent":"Šitas ID {0} neegzistuoja!",
+
+            "invalidType":"Šios valdos turi būti tipas: {0}!",
+            "propertyMissing":"Ši valda {0} šio objekto trūksta!",
+            "propertyOptional":"Ši valda {0} yra neprivalomas šiame objekte!",
+            "objectDisabled":"Šis objektas išjungtas, ijunkite jį naudodami {0}!",
+            "nullInvalid":"Ši valda negali būti niekinė!",
+            "switchInvalidType":"Tai turi būti vienas iš toliau nurodytų tipų: {0}!",
+            "objectSwitchInvalid":"Šis objektas turi būti vieno iš šių tipų: {0}!",
+
+            "invalidLanguage":"Neiteisinga Kalba!",
+            "invalidButton":"Šis mygtukas turi turėti bent {0} arba {1}!",
+            "unusedOption":"Šis pasirinkimas {0} nėra naudojamas!",
+            "unusedQuestion":"Klausimas {0} nėra naudojamas niekur!",
+            "dropdownOption":"Pasirinkimas su įjungtu išskleidžiamuoju meniu gali būti tik „bilieto“ tipo parinktys!"
+        }
+    },
+    "actions":{
+        "buttons":{
+            "create":"Aplankykite Bilietą",
+            "close":"Uždarykite Bilieta",
+            "delete":"Ištrinti Bilieta",
+            "reopen":"Atnaujinti Bilieta",
+            "claim":"Claim Bilieta",
+            "unclaim":"Unclaim Bilieta",
+            "pin":"Prisegti Bilieta",
+            "unpin":"Atsegti Bilieta",
+            "clear":"Ištrinti Bilieta",
+            "helpSwitchSlash":"Pamatyti Slash Komandas",
+            "helpSwitchText":"Peržiūrėti Teksto Komandas ",
+            "helpPage":"Puslapis {0}",
+            "withReason":"Su Priežastimi",
+            "withoutTranscript":"Be Išrašo"
+        },
+        "titles":{
+            "created":"Bilietas Sukurtas",
+            "close":"Bilietas Uždarytas",
+            "delete":"Bilietas Ištrintas",
+            "reopen":"Bilietas Atnaujintas",
+            "claim":"Bilietas Claimed",
+            "unclaim":"Bilietas Unclaimed",
+            "pin":"Bilietas Prisegtas",
+            "unpin":"Bilietas Atsegtas",
+            "rename":"Bilietas Pervadytas",
+            "move":"Bilietas Perkeltas",
+            "add":"Bilieto Naudotojas Pridėtas",
+            "remove":"Bilieto Naudotojas Pašalintas",
+            
+            "help":"Galimi Komandos",
+            "statsReset":"Atkurti Statusa",
+            "blacklistAdd":"Naudotojas Užblokuotas",
+            "blacklistRemove":"Naudotojas Atblokuotas",
+            "blacklistGet":"Naudotojas Užblokuotas",
+            "blacklistView":"Dabartinis Užblokavimai",
+            "blacklistAddDm":"Žmogus buvo užblokuotas",
+            "blacklistRemoveDm":"Pašalino užblokavima",
+            "clear":"Bilietai išvalyti",
+            "roles":"Roles Atnaujinti",
+            
+            "autoclose":"Bilietas automatiškai uždarytas",
+            "autocloseEnabled":"Automatinis uždarymas įjungtas",
+            "autocloseDisabled":"Automatinis uždarymas išjungtas",
+            "autodelete":"Bilietas automatiškai ištrintas",
+            "autodeleteEnabled":"Bilieto automatinis ištrynimas įjungtas",
+            "autodeleteDisabled":"Bilieto automatinis ištrynimas išjungtas"
+        },
+        "descriptions":{
+            "create":"Jūsų bilietas sukurtas. Spustelėkite toliau esantį mygtuką, kad jį pasiektumėte!",
+            "close":"Bilietas buvo sėkmingai uždarytas!",
+            "delete":"Bilietas buvo sėkmingai ištrintas!",
+            "reopen":"Bilietas buvo sėkmingai atidarytas!",
+            "claim":"Bilietas buvo sėkmingai claimed!",
+            "unclaim":"Bilietas buvo sėkmingai unclaimed!",
+            "pin":"Bilietas buvo sėkmingai prisegtas!",
+            "unpin":"Bilietas buvo sėkmingai atsegtas",
+            "rename":"Bilietas buvo pervadytas į {0} sėkmingai!",
+            "move":"Bilietas buvo perkeltas į {0} sėkmingai!",
+            "add":"{0} buvo pridėtas į bilieta sekmingai!",
+            "remove":"{0} buvo pašalintas iš bilieto sėkmingai!",
+
+            "helpExplanation":"`<pavadinimas>` => reikalingas parametras\n`[pavadinimas]` => pasirenkamas parametras",
+            "statsReset":"Boto statistika buvo sekmingai nustatyti iš naujo!",
+            "statsError":"Negaliu matyti bilieto statistikos!\n{0} nėra bilietas!",
+            "blacklistAdd":"{0} buvo sėkmingai užblokuotas!",
+            "blacklistRemove":"{0} buvo sėkmingai užblokuotas!",
+            "blacklistGetSuccess":"{0} yra užblokuotas!",
+            "blacklistGetEmpty":"{0} nėra užblokuotas!",
+            "blacklistViewEmpty":"Dar niekas nebuvo užblokuotas!",
+            "blacklistViewTip":"Norėdami užblokuoti naudotoja, naudokite \"/blacklist add\".!",
+            "clearVerify":"Ar tikrai norite ištrinti kelis bilietus?\nŠio veiksmo anuliuoti negalima!",
+            "clearReady":"{0} bilietai buvo sėkmingai pašalinti!",
+            "rolesEmpty":"Jokie roles nebuvo atnaujinti!",
+
+            "autocloseLeave":"Šis bilietas buvo automatiškai uždarytas, nes kūrėjas paliko serverį!",
+            "autocloseTimeout":"Šis bilietas buvo automatiškai uždarytas, nes buvo neaktyvus daugiau nei `{0}h`!",
+            "autodeleteLeave":"Šis bilietas buvo automatiškai ištrintas, nes kūrėjas paliko serverį!",
+            "autodeleteTimeout":"Šis bilietas buvo automatiškai ištrintas, nes buvo neaktyvus daugiau nei `{0} dienas`!",
+            "autocloseEnabled":"Šiame biliete įjungtas automatinis uždarymas!\nJis bus uždarytas, kai bus neaktyvus ilgiau nei `{0}h`!",
+            "autocloseDisabled":"Šiame biliete automatinis uždarymas išjungtas!\nJis nebebus automatiškai uždarytas!",
+            "autodeleteEnabled":"Šiame biliete įgalintas automatinis ištrynimas!\nJis bus ištrintas, kai bus neaktyvus ilgiau nei `{0} dienas`!",
+            "autodeleteDisabled":"Automatinis ištrynimas šiame biliete išjungtas!\nJis nebebus automatiškai ištrintas!",
+
+            "ticketMessageLimit":"Tu gali sukurti tik {0} bilietus tuo pačiu metu!",
+            "ticketMessageAutoclose":"Šis bilietas bus automatiškai uždarytas, kai bus neaktyvus {0}h!",
+            "ticketMessageAutodelete":"Šis bilietas bus automatiškai ištrintas, kai neaktyvus {0} dienas!",
+            "panelReady":"Žemiau rasite skydelį!\nŠį pranešimą dabar galima ištrinti!"
+        },
+        "modal":{
+            "closePlaceholder":"Kodėl tu uždarei šį bilieta?",
+            "deletePlaceholder":"Kodėl tu ištrinei šita bilieta?",
+            "reopenPlaceholder":"Kam tu atidarei bilieta?",
+            "claimPlaceholder":"Kam tu claimed šita bilieta?",
+            "unclaimPlaceholder":"Kam tu Unclaimed šita bilieta?",
+            "pinPlaceholder":"Kam tu prisegei šita bilieta?",
+            "unpinPlaceholder":"Kam tu atsegei šita bilieta?"
+        },
+        "logs":{
+            "createLog":"Naujas bilietas buvo sukurtas {0}!",
+            "closeLog":"šitas bilietas bus uždarytas už {0}!",
+            "closeDm":"Tavo bilietas buvo uždarytas!",
+            "deleteLog":"Šitas bilietas buvo ištrintas nuo {0}!",
+            "deleteDm":"Jūsų bilietas buvo ištrintas!",
+            "reopenLog":"Šitas bilietas buvo atidarytas nuo {0}!",
+            "reopenDm":"Tavo bilietas buvo atidarytas!",
+            "claimLog":"Šitas bilietas buvo claimed nuo {0}!",
+            "claimDm":"Tavo bilietas buvo claimed!",
+            "unclaimLog":"Bilietas buvo unclaimed nuo {0}!",
+            "unclaimDm":"Tavo bilietas buvo unclaimed!",
+            "pinLog":"This ticket has been pinned by {0}!",
+            "pinDm":"Bilietas buvo prisegtas!",
+            "unpinLog":"Bilietas buvo atsegtas nuo {0}!",
+            "unpinDm":"Tavo bilietas buvo atsegtas!",
+            "renameLog":"Šitas bilietas buvo pervadintas į {0} nuo {1}!",
+            "renameDm":"Tavo bilietas buvo pervadytas į {0}!",
+            "moveLog":"Šitas bilietas buvo perkeltas į {0} nuo {1}!",
+            "moveDm":"Tavo bilietas buvo perkeltas į {0}!",
+            "addLog":"{0} buvo pridėtas į bilieta nuo {1}!",
+            "addDm":"{0} Buvo pridėtas į tavo bilieta!",
+            "removeLog":"{0} buvo pašalintas iš šito bilieto nuo {1}!",
+            "removeDm":"{0} buvo pasalintas iš tavo bilieto!",
+
+            "blacklistAddLog":"{0} buvo užblokuotas nuo {1}!",
+            "blacklistRemoveLog":"{0} buvo atblokuotas nuo  {1}!",
+            "blacklistAddDm":"Jūs buvote užblokuotas!\nNuo šiol negalite sukurti bilieto!",
+            "blacklistRemoveDm":"Jūs buvote pašalinti iš juodojo sąrašo mūsų serveryje!\nDabar vėl galite kurti bilietus!",
+            "clearLog":"{0} bilietai buvo pašalinti nuo {1}!"
+        }
+    },
+    "transcripts":{
+        "success":{
+            "visit":"Peržiūrėti Išrašus",
+            "ready":"Išrašai sukurti",
+            "textFileDescription":"!",
+            "htmlProgress":"Palaukite, kol šis html išrašas bus apdorojamas...",
+
+            "createdChannel":"Naujas {0} išrašas buvo sukurtas!",
+            "createdCreator":"Naujas {0} vieno iš jūsų bilietų išrašas sukurtas!",
+            "createdParticipant":"Naujas {0} išrašas buvo sukurta viename iš bilietų, kuriuose dalyvavote!",
+            "createdActiveAdmin":"Naujas {0} išrašas buvo sukurta viename iš bilietų, kuriuose dalyvavote kaip administratorius!",
+            "createdEveryAdmin":"Naujas {0} išrašas buvo sukurta viename iš bilietų, kuriuose buvote administratorius!",
+            "createdOther":"Naujas {0} išrašas buvo sukurtas!"
+        },
+        "errors":{
+            "retry":"Bandyk Iš naujo",
+            "continue":"Ištrinti be išrašo",
+            "backup":"Sukurti Atsarginį išraša",
+            "error":"Kažkas nepavyko bandant sukurti išraša.\nKą norėtumėte daryti?\n\nŠis bilietas nebus ištrintas, kol spustelėsite vieną iš šių mygtukų."
+        }
+    },
+    "errors":{
+        "titles":{
+            "internalError":"Vidinė klaida",
+            "optionMissing":"Trūksta komandos parinkties",
+            "optionInvalid":"Netinkama komandos parinktis",
+            "unknownCommand":"Nepažystama komanda",
+            "noPermissions":"Jokių leidimų",
+            "unknownTicket":"Nepažystamas bilietas",
+            "deprecatedTicket":"Nebenaudojamas bilietas",
+            "unknownOption":"Nepažystamas pasirinkimas",
+            "unknownPanel":"Nepažystama skydelis",
+            "notInGuild":"Nera serveryje",
+            "channelRename":"Negaliu pervadyti kanalo",
+            "busy":"Bilietas yra užimtas"
+        },
+        "descriptions":{
+            "askForInfo":"Susisiek su savininku šito bilieto del daigiau informacijos!",
+            "askForInfoResolve":"Susisiekite su šio bot'o  savininku, jei ši problema neišsprendžiama po kelių bandymų.",
+            "internalError":"Nepavyko atsakyti į šį {0} dėl vidinės klaidos!",
+            "optionMissing":"Šioje komandoje trūksta būtino parametro!",
+            "optionInvalid":"Šios komandos parametras neteisingas!",
+            "optionInvalidChoose":"Pasirink tarp",
+            "unknownCommand":"Norėdami gauti daugiau informacijos, pabandykite apsilankyti pagalbos meniu!",
+            "noPermissions":"Jums neleidžiama to naudoti {0}!",
+            "noPermissionsList":"Reikalingas Leidimas: (vienas iš jų)",
+            "noPermissionsCooldown":"Jums neleidžiama naudoti šio {0}, nes reikia atvėsti!",
+            "noPermissionsBlacklist":"Jums neleidžiama naudoti šio {0}, nes buvote užblokuotas!",
+            "noPermissionsLimitGlobal":"Jums neleidžiama kurti bilieto, nes serveris pasiekė maksimalų bilietų limitą!",
+            "noPermissionsLimitGlobalUser":"Jums neleidžiama kurti bilieto, nes pasiekėte maksimalų bilietų limitą!",
+            "noPermissionsLimitOption":"Jums neleidžiama kurti bilieto, nes serveris pasiekė maksimalų šios parinkties bilietų limitą!",
+            "noPermissionsLimitOptionUser":"Jums neleidžiama kurti bilieto, nes pasiekėte maksimalų šios parinkties bilietų limitą!",
+            "unknownTicket":"Išbandykite šią komandą dar kartą naudodami galiojantį bilietą!",
+            "deprecatedTicket":"Dabartinis kanalas negalioja! Tai galėjo būti bilietas iš senos Open Ticket versijos!",
+            "notInGuild":"Šis {0} neveikia DM! Bandykite dar kartą serveryje!",
+            "channelRename":"Dėl discord'o greičio apribojimų, šiuo metu robotas negali pervardyti kanalo. Kanalas bus automatiškai pervardytas per 10 minučių, jei robotas nebus paleistas iš naujo.",
+            "channelRenameSource":"Šios klaidos šaltinis yra: {0}",
+            "busy":"Neįmanoma naudoti šio {0}!\nBilietą šiuo metu apdoroja botas.\n\nBandykite dar kartą po kelių sekundžių!"
+        },
+        "optionInvalidReasons":{
+            "stringRegex":"Vertė neatitinka šablono!",
+            "stringMinLength":"Reikšmė turi būti bent {0} simbolių!",
+            "stringMaxLength":"Reikšmę turi sudaryti daugiausia {0} simboliai!",
+            "numberInvalid":"Neteisingas numeris!",
+            "numberMin":"Skaičius turi būti bent {0}!",
+            "numberMax":"Skaičius turi būti didžiausias {0}!",
+            "numberDecimal":"Skaičius negali būti dešimtainis!",
+            "numberNegative":"Skaičius negali būti neigiamas!",
+            "numberPositive":"Skaičius negali būti teigiamas!",
+            "numberZero":"Skaičius negali būti nulis!",
+            "channelNotFound":"Negaliu surasti kanalo!",
+            "userNotFound":"Negaliu surasti naudotojo!",
+            "roleNotFound":"Negaliu surasti rolės!",
+            "memberNotFound":"negaliu surasti naudotojo!",
+            "mentionableNotFound":"negaliu surasti naudotojo arba rolės!",
+            "channelType":"Neteisingas kanalo tipas!",
+            "notInGuild":"Ši parinktis reikalauja, kad būtumėte serveryje!"
+        },
+        "permissions":{
+            "developer":"Tu turi būti developeris šito boto.",
+            "owner":"Tu turi būti serverio savininkas.",
+            "admin":"Tu turi būti serverio administratorius.",
+            "moderator":"Tu turi būt serverio moderatorius.",
+            "support":"Tu turi būti prižiūrėtojas.",
+            "member":"Tu turi būti narys.",
+            "discord-administrator":"Tu turi turėti `ADMINISTRATOR` leidima."
+        },
+        "actionInvalid":{
+            "close":"Bilietas yra jau uždarytas!",
+            "reopen":"Bilietas nėra uždarytas!",
+            "claim":"Bilietas jau yra claimed!",
+            "unclaim":"Bilietas nera claimed!",
+            "pin":"Bilietas jau yra prisegtas!",
+            "unpin":"Bilietas nėra prisegtas!",
+            "add":"Šitas naudotojas jau gali matyti šita bilieta!",
+            "remove":"Negaliu pašalinti naudotojo iš bilieto!"
+        }
+    },
+    "params":{
+        "uppercase":{
+            "ticket":"Bilietas",
+            "tickets":"Bilietao",
+            "reason":"Priežastis",
+            "creator":"Kūrėjas",
+            "remaining":"Liko laiko",
+            "added":"Pridėta",
+            "removed":"Pašalinta",
+            "filter":"Filteris",
+            "claimedBy":"Claimed nuo {0}",
+            "method":"Metodas",
+            "type":"Tipas",
+            "blacklisted":"Užblokuotas",
+            "panel":"Skydelis",
+            "command":"Komanda",
+            "system":"Sistema",
+            "true":"Teisingai",
+            "false":"Klaidingai",
+            "syntax":"Sintaksė",
+            "originalName":"Orginalus Pavadinimas",
+            "newName":"Naujas pavadinimas",
+            "until":"Iki",
+            "validOptions":"Galiojančios parinktys",
+            "validPanels":"Galiojančios Skydeliai",
+            "autoclose":"Automatinis uždarymas",
+            "autodelete":"Automatinis Ištrinimas",
+            "startupDate":"Paleidimo data",
+            "version":"Versija",
+            "name":"Pavadinimas",
+            "role":"Role",
+            "status":"Statusas",
+            "claimed":"Claimed",
+            "pinned":"Prisegta",
+            "creationDate":"Sukūrimo data"
+        },
+        "lowercase":{
+            "text":"tekstas",
+            "html":"html",
+            "command":"komanda",
+            "modal":"modal",
+            "button":"mygtukas",
+            "dropdown":"išskleidžiamas meniu",
+            "method":"metodas"
+        }
+    },
+    "commands":{
+        "reason":"Nurodykite pasirenkamą priežastį, kuri bus matoma veiksmo žurnaluose.",
+        "help":"Gaukite visų galimų komandų sąrašą.",
+        "panel":"Pateikite pranešimą išskleidžiamuoju meniu arba mygtukais (bilietui sukurti).",
+        "panelId":"Skydelio, kurį norite sukurti, identifikatorius.",
+        "panelAutoUpdate":"Ar norite, kad šis skydelis būtų automatiškai atnaujintas redaguojant?",
+        "ticket":"Iškart sukurkite bilietą.",
+        "ticketId":"Bilieto, kurį norite sukurti, identifikatorius.",
+        "close":"Uždaryti bilieta.",
+        "delete":"Ištrinti bilieta.",
+        "deleteNoTranscript":"Ištrinti šita bilieta nesukuriant išrašo.",
+        "reopen":"Atidaryti bilieta.",
+        "claim":"Claim bileta.",
+        "claimUser":"Claim bilieta kažka kita negu save.",
+        "unclaim":"Unclaim bilieta.",
+        "pin":"Prisegti bilieta.",
+        "unpin":"Atsegti bilieta.",
+        "move":"Perkelti bilieta.",
+        "moveId":"Parinkties, į kurią norite pereiti, identifikatorius.",
+        "rename":"Pervadinti bilieta.",
+        "renameName":"Naujas pavadinimas šitam bilietui.",
+        "add":"Pridėk naudotoja prie bilieto.",
+        "addUser":"Asmuo kurį norite pridėti.",
+        "remove":"Pašalinti naudotoja iš bilieto.",
+        "removeUser":"Pašalinti asmuo iš bilieto.",
+        "blacklist":"Tvarkykite bilietų užblokavimo sąrašą.",
+        "blacklistView":"Peržiūrėkite dabartinio užblokavimo sąrašą.",
+        "blacklistAdd":"Pridėk asmenį i užblokuoti saraša.",
+        "blacklistRemove":"Pašalinti asmenį iš užblokuotų sarašo.",
+        "blacklistGet":"Gaukite išsamią informaciją iš naudotojo kuris buvo užblokuotas.",
+        "blacklistGetUser":"Asmuo kurio nori gauti informacija.",
+        "stats":"Peržiūrėkite boto, nario ar bilieto statistiką.",
+        "statsReset":"Iš naujo nustatykite visą roboto statistiką (ir pradėkite skaičiuoti nuo nulio).",
+        "statsGlobal":"Peržiūrėkite pasaulinę statistiką.",
+        "statsUser":"Peržiūrėkite serverio vartotojo statistiką.",
+        "statsUserUser":"Asmuo kuri norite peržiūrėti.",
+        "statsTicket":"Peržiūrėkite bilieto statistiką serveryje.",
+        "statsTicketTicket":"Pamatyti Bilieta.",
+        "clear":"Ištrinkite kelis bilietus vienu metu.",
+        "clearFilter":"Bilietų išvalymo filtras.",
+        "clearFilters":{
+            "all":"Visus",
+            "open":"Atidarytus",
+            "close":"Uždarytus",
+            "claim":"Claimed",
+            "unclaim":"Unclaimed",
+            "pin":"Prisegtus",
+            "unpin":"Atsegtus",
+            "autoclose":"Automatinius uždarymus"
+        },
+        "autoclose":"Tvarkykite automatinį uždarymą biliete.",
+        "autocloseDisable":"Išjungti automatinį uždarymą šiame biliete.",
+        "autocloseEnable":"Įgalinti automatinį uždarymą šiame biliete.",
+        "autocloseEnableTime":"Norint jį uždaryti, šis bilietas turi būti neaktyvus.",
+        "autodelete":"Tvarkykite automatinį ištrynimą biliete.",
+        "autodeleteDisable":"Išjungti automatinį ištrynimą šiame biliete.",
+        "autodeleteEnable":"Įgalinti automatinį ištrynimą šiame biliete.",
+        "autodeleteEnableTime":"Kiek dienų šis bilietas turi būti neaktyvus, kad jį būtų galima ištrinti."
+    },
+    "helpMenu":{
+        "help":"Gauk saraša galimų komandų.",
+        "ticket":"Iškart atidaryk bilieta.",
+        "close":"Uždarykite bilietą, tai išjungs rašymą šiame kanale.",
+        "delete":"Ištrinkite bilietą. Kai įjungta, sukuriamas nuorašas.",
+        "reopen":"Iš naujo atidarykite bilietą, todėl vėl galėsite rašyti šiame kanale.",
+        "pin":"Prisekite bilietą. Taip bilietas bus perkeltas į viršų ir prie pavadinimo bus pridėta emocija „📌“..",
+        "unpin":"Atsegti bilietą. Bilietas liks savo pozicijoje, bet praras emociją „📌“..",
+        "move":"Perkelkite bilietą. Tai pakeis šio bilieto tipą.",
+        "rename":"Pervardykite bilietą. Tai pakeis šio bilieto kanalo pavadinimą.",
+        "claim":"CLaim bilieto. Taip galite pranešti savo komandai, kad tvarkote šį bilietą.",
+        "unclaim":"Unclaim bilietą. Taip galite pranešti savo komandai, kad šis bilietas vėl netvarkomas.",
+        "add":"Pridėkite vartotoją prie bilieto. Tai leis vartotojui skaityti ir rašyti šiame biliete.",
+        "remove":"Pašalinkite vartotoją iš bilieto. Tai pašalins vartotojo galimybę skaityti ir rašyti šiame biliete.",
+        "panel":"Pateikite pranešimą išskleidžiamuoju meniu arba mygtukais (bilietui sukurti).",
+        "blacklistView":"Peržiūrėkite dabartinio užblokuotų žmonių sąrašą.",
+        "blacklistAdd":"Užblokuok žmogų nuo kurimosi bikieto.",
+        "blacklistRemove":"Pašalinkite vartotoją iš juodojo sąrašo.",
+        "blacklistGet":"Gaukite išsamią informaciją iš naudotojo, įtraukto į juodąjį sąrašą.",
+        "statsGlobal":"Peržiūrėkite pasaulinę statistiką.",
+        "statsTicket":"Peržiūrėkite bilieto statistiką serveryje.",
+        "statsUser":"Peržiūrėkite serverio vartotojo statistiką.",
+        "statsReset":"Iš naujo nustatykite visą roboto statistiką (ir pradėkite skaičiuoti nuo nulio).",
+        "autocloseDisable":"Išjungti automatinį uždarymą šiame biliete.",
+        "autocloseEnable":"Įgalinti automatinį uždarymą šiame biliete.",
+        "autodeleteDisable":"Išjungti automatinį ištrynimą šiame biliete.",
+        "autodeleteEnable":"Įgalinti automatinį ištrynimą šiame biliete."
+    },
+    "stats":{
+        "scopes":{
+            "global":"Globalinė statistika",
+            "system":"Sisteminė statistika",
+            "user":"Naudotojo statistika",
+            "ticket":"Bilieto statistika",
+            "participants":"Dalyviai"
+        },
+        "properties":{
+            "ticketsCreated":"Bilietai Sukurti",
+            "ticketsClosed":"BILIETAI Uždaryti",
+            "ticketsDeleted":"Bilietai Ištrinti",
+            "ticketsReopened":"Bilietai Atnaujinti",
+            "ticketsAutoclosed":"Bilietai uždaryti automatiškai",
+            "ticketsClaimed":"Bilietai Claim",
+            "ticketsPinned":"Bilietai Prisegti",
+            "ticketsMoved":"Bilietai Perkelti",
+            "usersBlacklisted":"Naudojas Užblokuotas",
+            "transcriptsCreated":"Išrašai sukurti"
+        }
+    }
+}

languages/norwegian.json

@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.3",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Norwegian",
+        "automated": false
+    },
+    "checker": {
+        "system": {
+            "typeError": "[FEIL]",
+            "headerOpenTicket": "ÅPNE SAK",
+            "typeWarning": "[ADVARSEL]",
+            "typeInfo": "[INFO]",
+            "headerConfigChecker": "KONFIGURASJONSSJEKKER",
+            "headerDescription": "sjekk etter feil i konfigurasjonen din!",
+            "footerError": "boten starter ikke før alle {0} er fikset!",
+            "footerWarning": "det anbefales å fikse alle {0} før oppstart!",
+            "footerSupport": "STØTTE: {0} - DOKUMENTASJON: {1}",
+            "compactInformation": "bruk {0} for mer informasjon!",
+            "dataPath": "sti",
+            "dataDocs": "dokumentasjon",
+            "dataMessages": "melding"
+        },
+        "messages": {
+            "stringTooShort": "Denne strengen kan ikke være kortere enn {0} tegn!",
+            "stringTooLong": "Denne strengen kan ikke være lengre enn {0} tegn!",
+            "stringLengthInvalid": "Denne strengen skal være {0} tegn lang!",
+            "stringStartsWith": "Denne strengen skal starte med {0}!",
+            "stringEndsWith": "Denne strengen skal slutte med {0}!",
+            "stringContains": "Denne strengen skal inneholde {0}!",
+            "stringChoices": "Denne strengen kan kun være en av følgende verdier: {0}!",
+            "stringRegex": "Denne strengen er ugyldig!",
+  
+            "numberTooShort": "Dette tallet kan ikke være kortere enn {0} tegn!",
+            "numberTooLong": "Dette tallet kan ikke være lengre enn {0} tegn!",
+            "numberLengthInvalid": "Dette tallet skal være {0} tegn langt!",
+            "numberTooSmall": "Dette tallet skal være minst {0}!",
+            "numberTooLarge": "Dette tallet skal være høyst {0}!",
+            "numberNotEqual": "Dette tallet skal være {0}!",
+            "numberStep": "Dette tallet skal være et multiplum av {0}!",
+            "numberStepOffset": "Dette tallet skal være et multiplum av {0}, startende med {1}!",
+            "numberStartsWith": "Dette tallet skal starte med {0}!",
+            "numberEndsWith": "Dette tallet skal slutte med {0}!",
+            "numberContains": "Dette tallet skal inneholde {0}!",
+            "numberChoices": "Dette tallet kan kun være en av følgende verdier: {0}!",
+            "numberFloat": "Dette tallet kan ikke være et desimaltall!",
+            "numberNegative": "Dette tallet kan ikke være negativt!",
+            "numberPositive": "Dette tallet kan ikke være positivt!",
+            "numberZero": "Dette tallet kan ikke være null!",
+  
+            "booleanTrue": "Denne boolske verdien kan ikke være sann!",
+            "booleanFalse": "Denne boolske verdien kan ikke være usann!",
+
+            "arrayEmptyDisabled": "Denne listen kan ikke være tom!",
+            "arrayEmptyRequired": "Denne listen skal være tom!",
+            "arrayTooShort": "Denne listen skal ha en lengde på minst {0}!",
+            "arrayTooLong": "Denne listen skal ha en lengde på høyst {0}!",
+            "arrayLengthInvalid": "Denne listen skal ha en lengde på {0}!",
+            "arrayInvalidTypes": "Denne listen kan kun inneholde følgende typer: {0}!",
+            "arrayDouble": "Denne listen tillater ikke samme verdi to ganger!",
+  
+            "discordInvalidId": "Dette er en ugyldig Discord {0} ID!",
+            "discordInvalidIdOptions": "Dette er en ugyldig Discord {0} ID! Du kan også bruke en av disse: {1}!",
+            "discordInvalidToken": "Dette er et ugyldig Discord-token (syntaktisk)!",
+            "colorInvalid": "Dette er en ugyldig heksadesimal farge!",
+            "emojiTooShort": "Denne strengen skal ha minst {0} emojier!",
+            "emojiTooLong": "Denne strengen skal ha høyst {0} emojier!",
+            "emojiCustom": "Denne emojien kan ikke være en tilpasset Discord-emoji!",
+            "emojiInvalid": "Dette er en ugyldig emoji!",
+            "urlInvalid": "Denne URL-en er ugyldig!",
+            "urlInvalidHttp": "Denne URL-en kan kun bruke https://-protokollen!",
+            "urlInvalidProtocol": "Denne URL-en kan kun bruke http://- og https://-protokollene!",
+            "urlInvalidHostname": "Denne URL-en har et ikke-tillatt vertsnavn!",
+            "urlInvalidExtension": "Denne URL-en har en ugyldig filtype! Velg mellom: {0}!",
+            "urlInvalidPath": "Denne URL-en har en ugyldig sti!",
+            "idNotUnique": "Denne ID-en er ikke unik, bruk en annen ID i stedet!",
+            "idNonExistent": "ID-en {0} finnes ikke!",
+
+            "invalidType": "Denne egenskapen skal være av typen: {0}!",
+            "propertyMissing": "Egenskapen {0} mangler i dette objektet!",
+            "propertyOptional": "Egenskapen {0} er valgfri i dette objektet!",
+            "objectDisabled": "Dette objektet er deaktivert, aktiver det ved å bruke {0}!",
+            "nullInvalid": "Denne egenskapen kan ikke være null!",
+            "switchInvalidType": "Dette skal være en av følgende typer: {0}!",
+            "objectSwitchInvalid": "Dette objektet skal være en av følgende typer: {0}!",
+  
+            "invalidLanguage": "Dette er et ugyldig språk!",
+            "invalidButton": "Denne knappen skal ha minst en {0} eller {1}!",
+            "unusedOption": "Alternativet {0} brukes ikke noe sted!",
+            "unusedQuestion": "Spørsmålet {0} brukes ikke noe sted!",
+            "dropdownOption": "Et panel med nedtrekksmeny aktivert kan kun inneholde alternativer av typen 'sak'!"
+        }
+    },
+        "actions": {
+            "buttons": {
+                "create": "Opprett Sak",
+                "close": "Lukk Sak",
+                "delete": "Slett Sak",
+                "reopen": "Gjenåpne Sak",
+                "claim": "Ta Sak",
+                "unclaim": "Frigi Sak",
+                "pin": "Fest Sak",
+                "unpin": "Løsne Sak",
+                "clear": "Slett Saker",
+                "helpSwitchSlash": "Vis Skråstrekskommandoer",
+                "helpSwitchText": "Vis Tekstkommandoer",
+                "helpPage": "Side {0}",
+                "withReason": "Med Årsak",
+                "withoutTranscript": "Uten Utskrift"
+            },
+            "titles": {
+                "created": "Sak Opprettet",
+                "close": "Sak Lukket",
+                "delete": "Sak Slettet",
+                "reopen": "Sak Gjenåpnet",
+                "claim": "Sak Tatt",
+                "unclaim": "Sak Frigitt",
+                "pin": "Sak Festet",
+                "unpin": "Sak Løsnet",
+                "rename": "Sak Omdøpt",
+                "move": "Sak Flyttet",
+                "add": "Bruker Lagt Til Sak",
+                "remove": "Bruker Fjernet Fra Sak",
+    
+                "help": "Tilgjengelige Kommandoer",
+                "statsReset": "Tilbakestill Statistikk",
+                "blacklistAdd": "Bruker Svartelistet",
+                "blacklistRemove": "Bruker Fjernet Fra Svarteliste",
+                "blacklistGet": "Svartelistet Bruker",
+                "blacklistView": "Gjeldende Svarteliste",
+                "blacklistAddDm": "Lagt Til Svarteliste",
+                "blacklistRemoveDm": "Fjernet Fra Svarteliste",
+                "clear": "Saker Slettet",
+                "roles": "Roller Oppdatert",
+    
+                "autoclose": "Sak Autolukket",
+                "autocloseEnabled": "Autolukking Aktivert",
+                "autocloseDisabled": "Autolukking Deaktivert",
+                "autodelete": "Sak Autoslettet",
+                "autodeleteEnabled": "Autosletting Aktivert",
+                "autodeleteDisabled": "Autosletting Deaktivert"
+            },
+            "descriptions": {
+                "create": "Din sak er blitt opprettet. Klikk på knappen nedenfor for å få tilgang til den!",
+                "close": "Saken er blitt lukket vellykket!",
+                "delete": "Saken er blitt slettet vellykket!",
+                "reopen": "Saken er blitt gjenåpnet vellykket!",
+                "claim": "Saken er blitt tatt vellykket!",
+                "unclaim": "Saken er blitt frigitt vellykket!",
+                "pin": "Saken er blitt festet vellykket!",
+                "unpin": "Saken er blitt løsnet vellykket!",
+                "rename": "Saken er blitt omdøpt til {0} vellykket!",
+                "move": "Saken er blitt flyttet til {0} vellykket!",
+                "add": "{0} er blitt lagt til saken vellykket!",
+                "remove": "{0} er blitt fjernet fra saken vellykket!",
+    
+                "helpExplanation": "`<navn>` => påkrevd parameter\n`[navn]` => valgfri parameter",
+                "statsReset": "Botens statistikk er blitt tilbakestilt vellykket!",
+                "statsError": "Kan ikke vise saksstatistikk!\n{0} er ikke en sak!",
+                "blacklistAdd": "{0} er blitt svartelistet vellykket!",
+                "blacklistRemove": "{0} er blitt fjernet fra svartelisten vellykket!",
+                "blacklistGetSuccess": "{0} er for øyeblikket svartelistet!",
+                "blacklistGetEmpty": "{0} er for øyeblikket ikke svartelistet!",
+                "blacklistViewEmpty": "Ingen er svartelistet ennå!",
+                "blacklistViewTip": "Bruk \"/blacklist add\" for å svarteliste en bruker!",
+                "clearVerify": "Er du sikker på at du vil slette flere saker?\nDenne handlingen kan ikke angres!",
+                "clearReady": "{0} saker er blitt slettet vellykket!",
+                "rolesEmpty": "Ingen roller er blitt oppdatert!",
+    
+                "autocloseLeave": "Denne saken er blitt autolukket fordi oppretteren forlot serveren!",
+                "autocloseTimeout": "Denne saken er blitt autolukket fordi den har vært inaktiv i mer enn `{0}t`!",
+                "autodeleteLeave": "Denne saken er blitt autoslettet fordi oppretteren forlot serveren!",
+                "autodeleteTimeout": "Denne saken er blitt autoslettet fordi den har vært inaktiv i mer enn `{0} dager`!",
+                "autocloseEnabled": "Autolukking er blitt aktivert i denne saken!\nDen vil bli lukket når den er inaktiv i mer enn `{0}t`!",
+                "autocloseDisabled": "Autolukking er blitt deaktivert i denne saken!\nDen vil ikke lenger bli lukket automatisk!",
+                "autodeleteEnabled": "Autosletting er blitt aktivert i denne saken!\nDen vil bli slettet når den er inaktiv i mer enn `{0} dager`!",
+                "autodeleteDisabled": "Autosletting er blitt deaktivert i denne saken!\nDen vil ikke lenger bli slettet automatisk!",
+    
+                "ticketMessageLimit": "Du kan kun opprette {0} sak(er) om gangen!",
+                "ticketMessageAutoclose": "Denne saken vil bli autolukket når den er inaktiv i {0}t!",
+                "ticketMessageAutodelete": "Denne saken vil bli autoslettet når den er inaktiv i {0} dager!",
+                "panelReady": "Du finner panelet nedenfor!\nDenne meldingen kan nå slettes!"
+            },
+            "modal": {
+                "closePlaceholder": "Hvorfor lukket du denne saken?",
+                "deletePlaceholder": "Hvorfor slettet du denne saken?",
+                "reopenPlaceholder": "Hvorfor gjenåpnet du denne saken?",
+                "claimPlaceholder": "Hvorfor tok du denne saken?",
+                "unclaimPlaceholder": "Hvorfor frigjorde du denne saken?",
+                "pinPlaceholder": "Hvorfor festet du denne saken?",
+                "unpinPlaceholder": "Hvorfor løsnet du denne saken?"
+            },
+            "logs": {
+                "createLog": "En ny sak er blitt opprettet av {0}!",
+                "closeLog": "Denne saken er blitt lukket av {0}!",
+                "closeDm": "Din sak er blitt lukket på vår server!",
+                "deleteLog": "Denne saken er blitt slettet av {0}!",
+                "deleteDm": "Din sak er blitt slettet på vår server!",
+                "reopenLog": "Denne saken er blitt gjenåpnet av {0}!",
+                "reopenDm": "Din sak er blitt gjenåpnet på vår server!",
+                "claimLog": "Denne saken er blitt tatt av {0}!",
+                "claimDm": "Din sak er blitt tatt på vår server!",
+                "unclaimLog": "Denne saken er blitt frigitt av {0}!",
+                "unclaimDm": "Din sak er blitt frigitt på vår server!",
+                "pinLog": "Denne saken er blitt festet av {0}!",
+                "pinDm": "Din sak er blitt festet på vår server!",
+                "unpinLog": "Denne saken er blitt løsnet av {0}!",
+                "unpinDm": "Din sak er blitt løsnet på vår server!",
+                "renameLog": "Denne saken er blitt omdøpt til {0} av {1}!",
+                "renameDm": "Din sak er blitt omdøpt til {0} på vår server!",
+                "moveLog": "Denne saken er blitt flyttet til {0} av {1}!",
+                "moveDm": "Din sak er blitt flyttet til {0} på vår server!",
+                "addLog": "{0} er blitt lagt til denne saken av {1}!",
+                "addDm": "{0} er blitt lagt til din sak på vår server!",
+                "removeLog": "{0} er blitt fjernet fra denne saken av {1}!",
+                "removeDm": "{0} er blitt fjernet fra din sak på vår server!",
+    
+                "blacklistAddLog": "{0} er blitt svartelistet av {1}!",
+                "blacklistRemoveLog": "{0} er blitt fjernet fra svartelisten av {1}!",
+                "blacklistAddDm": "Du er blitt svartelistet på vår server!\nFra nå av kan du ikke opprette en sak!",
+                "blacklistRemoveDm": "Du er blitt fjernet fra svartelisten på vår server!\nNå kan du opprette saker igjen!",
+                "clearLog": "{0} saker er blitt slettet av {1}!"
+        }
+      },
+      "transcripts": {
+        "success": {
+            "visit": "Besøk Utskrift",
+            "ready": "Utskrift Opprettet",
+            "textFileDescription": "Dette er tekstutskriften av en slettet sak!",
+            "htmlProgress": "Vennligst vent mens denne HTML-utskriften blir behandlet...",
+
+            "createdChannel": "En ny {0} utskrift er blitt opprettet på serveren!",
+            "createdCreator": "En ny {0} utskrift er blitt opprettet for en av dine saker!",
+            "createdParticipant": "En ny {0} utskrift er blitt opprettet i en av sakene du deltok i!",
+            "createdActiveAdmin": "En ny {0} utskrift er blitt opprettet i en av sakene du deltok i som admin!",
+            "createdEveryAdmin": "En ny {0} utskrift er blitt opprettet i en av sakene du var admin i!",
+            "createdOther": "En ny {0} utskrift er blitt opprettet!"
+        },
+        "errors": {
+            "retry": "Prøv Igjen",
+            "continue": "Slett Uten Utskrift",
+            "backup": "Opprett Sikkerhetskopiutskrift",
+            "error": "Noe gikk galt under forsøket på å opprette utskriften.\nHva vil du gjøre?\n\nDenne saken vil ikke bli slettet før du klikker på en av disse knappene."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Intern Feil",
+            "optionMissing": "Kommandoalternativ Mangler",
+            "optionInvalid": "Ugyldig Kommandoalternativ",
+            "unknownCommand": "Ukjent Kommando",
+            "noPermissions": "Ingen Tillatelser",
+            "unknownTicket": "Ukjent Sak",
+            "deprecatedTicket": "Utdatert Sak",
+            "unknownOption": "Ukjent Alternativ",
+            "unknownPanel": "Ukjent Panel",
+            "notInGuild": "Ikke På Server",
+            "channelRename": "Kan Ikke Omdøpe Kanal",
+            "busy": "Saken Er Opptatt"
+        },
+        "descriptions": {
+            "askForInfo": "Kontakt eieren av denne boten for mer informasjon!",
+            "askForInfoResolve": "Kontakt eieren av denne boten hvis problemet ikke løser seg etter noen forsøk!",
+            "internalError": "Kunne ikke svare på denne {0} på grunn av en intern feil!",
+            "optionMissing": "En påkrevd parameter mangler i denne kommandoen!",
+            "optionInvalid": "En parameter i denne kommandoen er ugyldig!",
+            "optionInvalidChoose": "Velg mellom",
+            "unknownCommand": "Prøv å besøke hjelpmenyen for mer informasjon!",
+            "noPermissions": "Du har ikke tillatelse til å bruke denne {0}!",
+            "noPermissionsList": "Påkrevde tillatelser: (en av dem)",
+            "noPermissionsCooldown": "Du har ikke tillatelse til å bruke denne {0} fordi du har en nedkjølingsperiode!",
+            "noPermissionsBlacklist": "Du har ikke tillatelse til å bruke denne {0} fordi du er svartelistet!",
+            "noPermissionsLimitGlobal": "Du har ikke tillatelse til å opprette en sak fordi serveren har nådd maksgrensen for saker!",
+            "noPermissionsLimitGlobalUser": "Du har ikke tillatelse til å opprette en sak fordi du har nådd maksgrensen for saker!",
+            "noPermissionsLimitOption": "Du har ikke tillatelse til å opprette en sak fordi serveren har nådd maksgrensen for dette alternativet!",
+            "noPermissionsLimitOptionUser": "Du har ikke tillatelse til å opprette en sak fordi du har nådd maksgrensen for dette alternativet!",
+            "unknownTicket": "Prøv denne kommandoen igjen i en gyldig sak!",
+            "deprecatedTicket": "Den nåværende kanalen er ikke en gyldig sak! Den kan ha vært en sak fra en eldre versjon av Open Ticket!",
+            "notInGuild": "Denne {0} fungerer ikke i DM! Prøv igjen på en server!",
+            "channelRename": "På grunn av Discords hastighetsbegrensninger er det for øyeblikket umulig for boten å omdøpe kanalen. Kanalen vil automatisk bli omdøpt innen 10 minutter hvis boten ikke startes på nytt.",
+            "channelRenameSource": "Kilden til denne feilen er: {0}",
+            "busy": "Kan ikke bruke denne {0}!\nSaken behandles for øyeblikket av boten.\n\nPrøv igjen om noen sekunder!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Verdien samsvarer ikke med mønsteret!",
+            "stringMinLength": "Verdien skal være minst {0} tegn!",
+            "stringMaxLength": "Verdien skal være høyst {0} tegn!",
+            "numberInvalid": "Ugyldig tall!",
+            "numberMin": "Tallet skal være minst {0}!",
+            "numberMax": "Tallet skal være høyst {0}!",
+            "numberDecimal": "Tallet kan ikke være et desimaltall!",
+            "numberNegative": "Tallet kan ikke være negativt!",
+            "numberPositive": "Tallet kan ikke være positivt!",
+            "numberZero": "Tallet kan ikke være null!",
+            "channelNotFound": "Kan ikke finne kanalen!",
+            "userNotFound": "Kan ikke finne brukeren!",
+            "roleNotFound": "Kan ikke finne rollen!",
+            "memberNotFound": "Kan ikke finne brukeren!",
+            "mentionableNotFound": "Kan ikke finne brukeren eller rollen!",
+            "channelType": "Ugyldig kanaltype!",
+            "notInGuild": "Dette alternativet krever at du er på en server!"
+        },
+        "permissions": {
+            "developer": "Du må være utvikleren av boten.",
+            "owner": "Du må være servereieren.",
+            "admin": "Du må være serveradministrator.",
+            "moderator": "Du må være moderator.",
+            "support": "Du må være en del av støtteteamet.",
+            "member": "Du må være medlem.",
+            "discord-administrator": "Du må ha `ADMINISTRATOR`-tillatelsen."
+        },
+        "actionInvalid": {
+            "close": "Saken er allerede lukket!",
+            "reopen": "Saken er ikke lukket ennå!",
+            "claim": "Saken er allerede tatt!",
+            "unclaim": "Saken er ikke tatt ennå!",
+            "pin": "Saken er allerede festet!",
+            "unpin": "Saken er ikke festet ennå!",
+            "add": "Denne brukeren har allerede tilgang til saken!",
+            "remove": "Kan ikke fjerne denne brukeren fra saken!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Sak",
+            "tickets": "Saker",
+            "reason": "Årsak",
+            "creator": "Oppretter",
+            "remaining": "Tid Igjen",
+            "added": "Lagt Til",
+            "removed": "Fjernet",
+            "filter": "Filter",
+            "claimedBy": "Tatt Av {0}",
+            "method": "Metode",
+            "type": "Type",
+            "blacklisted": "Svartelistet",
+            "panel": "Panel",
+            "command": "Kommando",
+            "system": "System",
+            "true": "Sann",
+            "false": "Usann",
+            "syntax": "Syntaks",
+            "originalName": "Opprinnelig Navn",
+            "newName": "Nytt Navn",
+            "until": "Til",
+            "validOptions": "Gyldige Alternativer",
+            "validPanels": "Gyldige Paneler",
+            "autoclose": "Autolukking",
+            "autodelete": "Autosletting",
+            "startupDate": "Oppstartsdato",
+            "version": "Versjon",
+            "name": "Navn",
+            "role": "Rolle",
+            "status": "Status",
+            "claimed": "Tatt",
+            "pinned": "Festet",
+            "creationDate": "Opprettelsesdato"
+        },
+        "lowercase": {
+            "text": "tekst",
+            "html": "html",
+            "command": "kommando",
+            "modal": "modal",
+            "button": "knapp",
+            "dropdown": "nedtrekksmeny",
+            "method": "metode"
+        }
+    },
+    "commands": {
+        "reason": "Angi en valgfri årsak som vil være synlig i loggene.",
+        "help": "Få en liste over alle tilgjengelige kommandoer.",
+        "panel": "Opprett en melding med en nedtrekksmeny eller knapper (for sakopprettelse).",
+        "panelId": "Identifikatoren for panelet du vil opprette.",
+        "panelAutoUpdate": "Ønsker du at dette panelet skal oppdatere seg automatisk når det redigeres?",
+        "ticket": "Opprett en sak med det samme.",
+        "ticketId": "Identifikatoren for saken du vil opprette.",
+        "close": "Lukk en sak.",
+        "delete": "Slett en sak.",
+        "deleteNoTranscript": "Slett denne saken uten å opprette en utskrift.",
+        "reopen": "Gjenåpne en sak.",
+        "claim": "Ta en sak.",
+        "claimUser": "Ta denne saken for en annen bruker i stedet for deg selv.",
+        "unclaim": "Frigi en sak.",
+        "pin": "Fest en sak.",
+        "unpin": "Løsne en sak.",
+        "move": "Flytt en sak.",
+        "moveId": "Identifikatoren for alternativet du vil flytte til.",
+        "rename": "Omdøp en sak.",
+        "renameName": "Det nye navnet på denne saken.",
+        "add": "Legg til en bruker i en sak.",
+        "addUser": "Brukeren som skal legges til.",
+        "remove": "Fjern en bruker fra en sak.",
+        "removeUser": "Brukeren som skal fjernes.",
+        "blacklist": "Administrer svartelisten for saker.",
+        "blacklistView": "Vis en liste over gjeldende svarteliste.",
+        "blacklistAdd": "Legg til en bruker på svartelisten.",
+        "blacklistRemove": "Fjern en bruker fra svartelisten.",
+        "blacklistGet": "Hent detaljer om en svartelistet bruker.",
+        "blacklistGetUser": "Brukeren å hente detaljer fra.",
+        "stats": "Vis statistikk fra boten, en bruker eller en sak.",
+        "statsReset": "Tilbakestill all statistikk for boten (og start tellingen fra null).",
+        "statsGlobal": "Vis global statistikk.",
+        "statsUser": "Vis statistikk fra en bruker på serveren.",
+        "statsUserUser": "Brukeren som skal vises.",
+        "statsTicket": "Vis statistikk for en sak på serveren.",
+        "statsTicketTicket": "Saken som skal vises.",
+        "clear": "Slett flere saker samtidig.",
+        "clearFilter": "Filteret for å slette saker.",
+        "clearFilters": {
+            "all": "Alle",
+            "open": "Åpne",
+            "close": "Lukkede",
+            "claim": "Tatte",
+            "unclaim": "Frigitte",
+            "pin": "Festede",
+            "unpin": "Løsnede",
+            "autoclose": "Autolukkede"
+        },
+        "autoclose": "Administrer autolukking i en sak.",
+        "autocloseDisable": "Deaktiver autolukking i denne saken.",
+        "autocloseEnable": "Aktiver autolukking i denne saken.",
+        "autocloseEnableTime": "Antall timer denne saken må være inaktiv før den lukkes.",
+        "autodelete": "Administrer autosletting i en sak.",
+        "autodeleteDisable": "Deaktiver autosletting i denne saken.",
+        "autodeleteEnable": "Aktiver autosletting i denne saken.",
+        "autodeleteEnableTime": "Antall dager denne saken må være inaktiv før den slettes."
+    },
+    "helpMenu": {
+        "help": "Få en liste over alle tilgjengelige kommandoer.",
+        "ticket": "Opprett en sak med det samme.",
+        "close": "Lukk en sak, dette deaktiverer skriving i kanalen.",
+        "delete": "Slett en sak, dette oppretter en utskrift når det er aktivert.",
+        "reopen": "Gjenåpne en sak, dette aktiverer skriving i kanalen igjen.",
+        "pin": "Fest en sak. Dette flytter saken til toppen og legger til en '📌' emoji i navnet.",
+        "unpin": "Løsne en sak. Saken blir værende på plass, men mister '📌' emojien.",
+        "move": "Flytt en sak. Dette endrer typen på saken.",
+        "rename": "Omdøp en sak. Dette endrer kanalnavnet på saken.",
+        "claim": "Ta en sak. Dette lar teamet ditt vite at du håndterer saken.",
+        "unclaim": "Frigi en sak. Dette lar teamet ditt vite at saken er ledig igjen.",
+        "add": "Legg til en bruker i en sak. Dette gir brukeren tilgang til å lese og skrive i saken.",
+        "remove": "Fjern en bruker fra en sak. Dette fjerner brukerens tilgang til å lese og skrive i saken.",
+        "panel": "Opprett en melding med en nedtrekksmeny eller knapper (for sakopprettelse).",
+        "blacklistView": "Vis en liste over gjeldende svarteliste.",
+        "blacklistAdd": "Legg til en bruker på svartelisten.",
+        "blacklistRemove": "Fjern en bruker fra svartelisten.",
+        "blacklistGet": "Hent detaljer om en svartelistet bruker.",
+        "statsGlobal": "Vis global statistikk.",
+        "statsTicket": "Vis statistikk for en sak på serveren.",
+        "statsUser": "Vis statistikk fra en bruker på serveren.",
+        "statsReset": "Tilbakestill all statistikk for boten (og start tellingen fra null).",
+        "autocloseDisable": "Deaktiver autolukking i denne saken.",
+        "autocloseEnable": "Aktiver autolukking i denne saken.",
+        "autodeleteDisable": "Deaktiver autosletting i denne saken.",
+        "autodeleteEnable": "Aktiver autosletting i denne saken."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Global Statistikk",
+            "system": "Systemstatistikk",
+            "user": "Brukerstatistikk",
+            "ticket": "Saksstatistikk",
+            "participants": "Deltakere"
+        },
+        "properties": {
+            "ticketsCreated": "Saker Opprettet",
+            "ticketsClosed": "Saker Lukket",
+            "ticketsDeleted": "Saker Slettet",
+            "ticketsReopened": "Saker Gjenåpnet",
+            "ticketsAutoclosed": "Saker Autolukket",
+            "ticketsClaimed": "Saker Tatt",
+            "ticketsPinned": "Saker Festet",
+            "ticketsMoved": "Saker Flyttet",
+            "usersBlacklisted": "Brukere Svartelistet",
+            "transcriptsCreated": "Utskrifter Opprettet"
+        }
+    }
+}

languages/polish.json

@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION":{
+        "otversion":"v4.0.3",
+        "translators":["DanoGlez"],
+        "lastedited":"28/01/2025",
+        "language":"Polish",
+        "automated":false
+    },
+    "checker":{
+        "system":{
+            "typeError":"[BŁĄD]",
+            "headerOpenTicket":"OTWÓRZ TICKET",
+            "typeWarning":"[OSTRZEŻENIE]",
+            "typeInfo":"[INFO]",
+            "headerConfigChecker":"SPRAWDZANIE KONFIGURACJI",
+            "headerDescription":"sprawdź błędy w swoich plikach konfiguracyjnych!",
+            "footerError":"bot nie uruchomi się, dopóki wszystkie {0} nie zostaną naprawione!",
+            "footerWarning":"zaleca się naprawienie wszystkich {0} przed uruchomieniem!",
+            "footerSupport":"WSPARCIE: {0} - DOKUMENTACJA: {1}",
+            "compactInformation":"użyj {0}, aby uzyskać więcej informacji!",
+            "dataPath":"ścieżka",
+            "dataDocs":"dokumentacja",
+            "dataMessages":"wiadomość"
+        },
+        "messages":{
+            "stringTooShort":"Ten tekst nie może być krótszy niż {0} znaków!",
+            "stringTooLong":"Ten tekst nie może być dłuższy niż {0} znaków!",
+            "stringLengthInvalid":"Ten tekst musi mieć {0} znaków!",
+            "stringStartsWith":"Ten tekst musi zaczynać się od {0}!",
+            "stringEndsWith":"Ten tekst musi kończyć się na {0}!",
+            "stringContains":"Ten tekst musi zawierać {0}!",
+            "stringChoices":"Ten tekst może być tylko jednym z następujących wartości: {0}!",
+            "stringRegex":"Ten tekst jest nieprawidłowy!",
+
+            "numberTooShort":"Ta liczba nie może być krótsza niż {0} znaków!",
+            "numberTooLong":"Ta liczba nie może być dłuższa niż {0} znaków!",
+            "numberLengthInvalid":"Ta liczba musi mieć {0} znaków!",
+            "numberTooSmall":"Ta liczba musi wynosić co najmniej {0}!",
+            "numberTooLarge":"Ta liczba może wynosić maksymalnie {0}!",
+            "numberNotEqual":"Ta liczba musi wynosić {0}!",
+            "numberStep":"Ta liczba musi być wielokrotnością {0}!",
+            "numberStepOffset":"Ta liczba musi być wielokrotnością {0}, zaczynając od {1}!",
+            "numberStartsWith":"Ta liczba musi zaczynać się od {0}!",
+            "numberEndsWith":"Ta liczba musi kończyć się na {0}!",
+            "numberContains":"Ta liczba musi zawierać {0}!",
+            "numberChoices":"Ta liczba może być tylko jedną z następujących wartości: {0}!",
+            "numberFloat":"Ta liczba nie może być dziesiętna!",
+            "numberNegative":"Ta liczba nie może być ujemna!",
+            "numberPositive":"Ta liczba nie może być dodatnia!",
+            "numberZero":"Ta liczba nie może wynosić zero!",
+
+            "booleanTrue":"Ta wartość logiczna nie może być prawdziwa!",
+            "booleanFalse":"Ta wartość logiczna nie może być fałszywa!",
+
+            "arrayEmptyDisabled":"Ta tablica nie może być pusta!",
+            "arrayEmptyRequired":"Ta tablica musi być pusta!",
+            "arrayTooShort":"Ta tablica musi mieć co najmniej {0} elementów!",
+            "arrayTooLong":"Ta tablica może mieć maksymalnie {0} elementów!",
+            "arrayLengthInvalid":"Ta tablica musi mieć {0} elementów!",
+            "arrayInvalidTypes":"Ta tablica może zawierać tylko następujące typy: {0}!",
+            "arrayDouble":"Ta tablica nie może zawierać tych samych wartości dwukrotnie!",
+
+            "discordInvalidId":"To jest nieprawidłowe ID Discorda {0}!",
+            "discordInvalidIdOptions":"To jest nieprawidłowe ID Discorda {0}! Możesz również użyć jednego z tych: {1}!",
+            "discordInvalidToken":"To jest nieprawidłowy token Discorda (składniowo)!",
+            "colorInvalid":"To jest nieprawidłowy kolor w formacie hex!",
+            "emojiTooShort":"Ten tekst musi zawierać co najmniej {0} emoji!",
+            "emojiTooLong":"Ten tekst może zawierać maksymalnie {0} emoji!",
+            "emojiCustom":"To emoji nie może być niestandardowym emoji Discorda!",
+            "emojiInvalid":"To jest nieprawidłowe emoji!",
+            "urlInvalid":"Ten URL jest nieprawidłowy!",
+            "urlInvalidHttp":"Ten URL może korzystać tylko z protokołu https://!",
+            "urlInvalidProtocol":"Ten URL może korzystać tylko z protokołów http:// i https://!",
+            "urlInvalidHostname":"Ten URL ma niedozwoloną nazwę hosta!",
+            "urlInvalidExtension":"Ten URL ma nieprawidłowe rozszerzenie! Wybierz spośród: {0}!",
+            "urlInvalidPath":"Ten URL ma nieprawidłową ścieżkę!",
+            "idNotUnique":"To ID nie jest unikalne, użyj innego ID!",
+            "idNonExistent":"ID {0} nie istnieje!",
+
+            "invalidType":"Ta właściwość musi być typu: {0}!",
+            "propertyMissing":"Właściwość {0} jest wymagana w tym obiekcie!",
+            "propertyOptional":"Właściwość {0} jest opcjonalna w tym obiekcie!",
+            "objectDisabled":"Ten obiekt jest wyłączony, włącz go za pomocą {0}!",
+            "nullInvalid":"Ta właściwość nie może być null!",
+            "switchInvalidType":"To musi być jeden z następujących typów: {0}!",
+            "objectSwitchInvalid":"Ten obiekt musi być jednym z następujących typów: {0}!",
+
+            "invalidLanguage":"To jest nieprawidłowy język!",
+            "invalidButton":"Ten przycisk musi zawierać co najmniej {0} lub {1}!",
+            "unusedOption":"Opcja {0} nie jest nigdzie używana!",
+            "unusedQuestion":"Pytanie {0} nie jest nigdzie używane!",
+            "dropdownOption":"Panel z włączonym rozwijanym menu może zawierać tylko opcje typu 'ticket'!"
+        }
+    },
+    "actions":{
+        "buttons":{
+            "create":"Otwórz Ticket",
+            "close":"Zamknij Ticket",
+            "delete":"Usuń Ticket",
+            "reopen":"Otwórz ponownie Ticket",
+            "claim":"Przejmij Ticket",
+            "unclaim":"Porzuć Ticket",
+            "pin":"Przypnij Ticket",
+            "unpin":"Odepnij Ticket",
+            "clear":"Usuń Tickety",
+            "helpSwitchSlash":"Pokaż Komendy Slash",
+            "helpSwitchText":"Pokaż Komendy Tekstowe",
+            "helpPage":"Strona {0}",
+            "withReason":"Z Powodem",
+            "withoutTranscript":"Bez Transkrypcji"
+        },
+        "titles":{
+            "created":"Ticket Utworzony",
+            "close":"Ticket Zamknięty",
+            "delete":"Ticket Usunięty",
+            "reopen":"Ticket Ponownie Otwarty",
+            "claim":"Ticket Przejety",
+            "unclaim":"Ticket Porzucony",
+            "pin":"Ticket Przypięty",
+            "unpin":"Ticket Odpięty",
+            "rename":"Ticket Przemianowany",
+            "move":"Ticket Przeniesiony",
+            "add":"Użytkownik Dodany do Ticketa",
+            "remove":"Użytkownik Usunięty z Ticketa",
+            
+            "help":"Dostępne Komendy",
+            "statsReset":"Statystyki Zresetowane",
+            "blacklistAdd":"Użytkownik Zablokowany",
+            "blacklistRemove":"Użytkownik Odblokowany",
+            "blacklistGet":"Zablokowany Użytkownik",
+            "blacklistView":"Aktualna Lista Zablokowanych",
+            "blacklistAddDm":"Dodano do Listy Zablokowanych",
+            "blacklistRemoveDm":"Usunięto z Listy Zablokowanych",
+            "clear":"Tickety Usunięte",
+            "roles":"Role Zaktualizowane",
+            
+            "autoclose":"Ticket Automatycznie Zamknięty",
+            "autocloseEnabled":"Automatyczne Zamknięcie Włączone",
+            "autocloseDisabled":"Automatyczne Zamknięcie Wyłączone",
+            "autodelete":"Ticket Automatycznie Usunięty",
+            "autodeleteEnabled":"Automatyczne Usuwanie Włączone",
+            "autodeleteDisabled":"Automatyczne Usuwanie Wyłączone"
+        },
+        "descriptions":{
+			"create":"Twój ticket został utworzony. Kliknij poniższy przycisk, aby go otworzyć!",
+			"close":"Ticket został pomyślnie zamknięty!",
+			"delete":"Ticket został pomyślnie usunięty!",
+			"reopen":"Ticket został pomyślnie ponownie otwarty!",
+			"claim":"Ticket został pomyślnie przypisany!",
+			"unclaim":"Ticket został pomyślnie odpisany!",
+			"pin":"Ticket został pomyślnie przypięty!",
+			"unpin":"Ticket został pomyślnie odpięty!",
+			"rename":"Ticket został pomyślnie przemianowany na {0}!",
+			"move":"Ticket został pomyślnie przeniesiony do {0}!",
+			"add":"{0} został pomyślnie dodany do ticketa!",
+			"remove":"{0} został pomyślnie usunięty z ticketa!",
+
+			"helpExplanation":"`<name>` => wymagany parametr\n`[name]` => opcjonalny parametr",
+			"statsReset":"Statystyki bota zostały pomyślnie zresetowane!",
+			"statsError":"Nie można wyświetlić statystyk ticketa!\n{0} nie jest ticketem!",
+			"blacklistAdd":"{0} został pomyślnie dodany do czarnej listy!",
+			"blacklistRemove":"{0} został pomyślnie usunięty z czarnej listy!",
+			"blacklistGetSuccess":"{0} jest obecnie na czarnej liście!",
+			"blacklistGetEmpty":"{0} nie znajduje się obecnie na czarnej liście!",
+			"blacklistViewEmpty":"Nikt nie został jeszcze dodany do czarnej listy!",
+			"blacklistViewTip":"Użyj \"/blacklist add\", aby dodać użytkownika do czarnej listy!",
+			"clearVerify":"Czy na pewno chcesz usunąć wiele ticketów?\nTej operacji nie można cofnąć!",
+			"clearReady":"{0} ticketów zostało pomyślnie usuniętych!",
+			"rolesEmpty":"Nie zaktualizowano żadnych ról!",
+
+			"autocloseLeave":"Ten ticket został automatycznie zamknięty, ponieważ jego twórca opuścił serwer!",
+			"autocloseTimeout":"Ten ticket został automatycznie zamknięty z powodu braku aktywności przez więcej niż `{0}h`!",
+			"autodeleteLeave":"Ten ticket został automatycznie usunięty, ponieważ jego twórca opuścił serwer!",
+			"autodeleteTimeout":"Ten ticket został automatycznie usunięty z powodu braku aktywności przez więcej niż `{0} dni`!",
+			"autocloseEnabled":"Autoczynność została włączona w tym tickecie!\nZostanie on zamknięty, jeśli będzie nieaktywny przez więcej niż `{0}h`!",
+			"autocloseDisabled":"Autoczynność została wyłączona w tym tickecie!\nNie będzie on już zamykany automatycznie!",
+			"autodeleteEnabled":"Autousuwanie zostało włączone w tym tickecie!\nZostanie on usunięty, jeśli będzie nieaktywny przez więcej niż `{0} dni`!",
+			"autodeleteDisabled":"Autousuwanie zostało wyłączone w tym tickecie!\nNie będzie on już usuwany automatycznie!",
+
+			"ticketMessageLimit":"Możesz utworzyć maksymalnie {0} ticket(y) jednocześnie!",
+			"ticketMessageAutoclose":"Ten ticket zostanie automatycznie zamknięty, jeśli będzie nieaktywny przez {0}h!",
+			"ticketMessageAutodelete":"Ten ticket zostanie automatycznie usunięty, jeśli będzie nieaktywny przez {0} dni!",
+			"panelReady":"Panel znajduje się poniżej!\nTeraz możesz usunąć tę wiadomość!"
+		},
+		"modal":{
+			"closePlaceholder":"Dlaczego zamknąłeś ten ticket?",
+			"deletePlaceholder":"Dlaczego usunąłeś ten ticket?",
+			"reopenPlaceholder":"Dlaczego ponownie otworzyłeś ten ticket?",
+			"claimPlaceholder":"Dlaczego przypisałeś ten ticket?",
+			"unclaimPlaceholder":"Dlaczego odpisano ten ticket?",
+			"pinPlaceholder":"Dlaczego przypiąłeś ten ticket?",
+			"unpinPlaceholder":"Dlaczego odpiąłeś ten ticket?"
+		},
+		"logs":{
+			"createLog":"Nowy ticket został utworzony przez {0}!",
+			"closeLog":"Ten ticket został zamknięty przez {0}!",
+			"closeDm":"Twój ticket został zamknięty na naszym serwerze!",
+			"deleteLog":"Ten ticket został usunięty przez {0}!",
+			"deleteDm":"Twój ticket został usunięty na naszym serwerze!",
+			"reopenLog":"Ten ticket został ponownie otwarty przez {0}!",
+			"reopenDm":"Twój ticket został ponownie otwarty na naszym serwerze!",
+			"claimLog":"Ten ticket został przypisany przez {0}!",
+			"claimDm":"Twój ticket został przypisany na naszym serwerze!",
+			"unclaimLog":"Ten ticket został odpisany przez {0}!",
+			"unclaimDm":"Twój ticket został odpisany na naszym serwerze!",
+			"pinLog":"Ten ticket został przypięty przez {0}!",
+			"pinDm":"Twój ticket został przypięty na naszym serwerze!",
+			"unpinLog":"Ten ticket został odpięty przez {0}!",
+			"unpinDm":"Twój ticket został odpięty na naszym serwerze!",
+			"renameLog":"Ten ticket został przemianowany na {0} przez {1}!",
+			"renameDm":"Twój ticket został przemianowany na {0} na naszym serwerze!",
+			"moveLog":"Ten ticket został przeniesiony do {0} przez {1}!",
+			"moveDm":"Twój ticket został przeniesiony do {0} na naszym serwerze!",
+			"addLog":"{0} został dodany do tego ticketa przez {1}!",
+			"addDm":"{0} został dodany do twojego ticketa na naszym serwerze!",
+			"removeLog":"{0} został usunięty z tego ticketa przez {1}!",
+			"removeDm":"{0} został usunięty z twojego ticketa na naszym serwerze!",
+
+			"blacklistAddLog":"{0} został dodany do czarnej listy przez {1}!",
+			"blacklistRemoveLog":"{0} został usunięty z czarnej listy przez {1}!",
+			"blacklistAddDm":"Zostałeś dodany do czarnej listy na naszym serwerze!\nOd teraz nie możesz tworzyć ticketów!",
+			"blacklistRemoveDm":"Zostałeś usunięty z czarnej listy na naszym serwerze!\nTeraz możesz ponownie tworzyć tickety!",
+			"clearLog":"{0} ticketów zostało usuniętych przez {1}!"
+		}
+    },
+    "transcripts":{
+		"success":{
+			"visit":"Otwórz transkrypt",
+			"ready":"Transkrypt został utworzony",
+			"textFileDescription":"To jest tekstowy transkrypt usuniętego ticketa!",
+			"htmlProgress":"Proszę czekać, trwa przetwarzanie tego transkryptu w formacie HTML...",
+
+			"createdChannel":"Nowy transkrypt {0} został utworzony na serwerze!",
+			"createdCreator":"Nowy transkrypt {0} został utworzony dla jednego z twoich ticketów!",
+			"createdParticipant":"Nowy transkrypt {0} został utworzony w jednym z ticketów, w których brałeś udział!",
+			"createdActiveAdmin":"Nowy transkrypt {0} został utworzony w jednym z ticketów, w których brałeś udział jako administrator!",
+			"createdEveryAdmin":"Nowy transkrypt {0} został utworzony w jednym z ticketów, w których byłeś administratorem!",
+			"createdOther":"Nowy transkrypt {0} został utworzony!"
+		},
+		"errors":{
+			"retry":"Spróbuj ponownie",
+			"continue":"Usuń bez transkryptu",
+			"backup":"Utwórz kopię zapasową transkryptu",
+			"error":"Coś poszło nie tak podczas próby utworzenia transkryptu.\nCo chciałbyś zrobić?\n\nTen ticket nie zostanie usunięty, dopóki nie klikniesz jednego z tych przycisków."
+		}
+	},
+    "errors":{
+		"titles":{
+			"internalError":"Błąd wewnętrzny",
+			"optionMissing":"Brakująca opcja polecenia",
+			"optionInvalid":"Nieprawidłowa opcja polecenia",
+			"unknownCommand":"Nieznane polecenie",
+			"noPermissions":"Brak uprawnień",
+			"unknownTicket":"Nieznany ticket",
+			"deprecatedTicket":"Przestarzały ticket",
+			"unknownOption":"Nieznana opcja",
+			"unknownPanel":"Nieznany panel",
+			"notInGuild":"Nie na serwerze",
+			"channelRename":"Nie można zmienić nazwy kanału",
+			"busy":"Ticket jest zajęty"
+		},
+		"descriptions":{
+			"askForInfo":"Skontaktuj się z właścicielem tego bota, aby uzyskać więcej informacji!",
+			"askForInfoResolve":"Skontaktuj się z właścicielem bota, jeśli problem nie rozwiąże się po kilku próbach.",
+			"internalError":"Nie udało się odpowiedzieć na to {0} z powodu błędu wewnętrznego!",
+			"optionMissing":"Brak wymaganego parametru w tym poleceniu!",
+			"optionInvalid":"Parametr w tym poleceniu jest nieprawidłowy!",
+			"optionInvalidChoose":"Wybierz spośród",
+			"unknownCommand":"Spróbuj odwiedzić menu pomocy, aby uzyskać więcej informacji!",
+			"noPermissions":"Nie masz uprawnień do użycia tego {0}!",
+			"noPermissionsList":"Wymagane uprawnienia: (jedno z nich)",
+			"noPermissionsCooldown":"Nie możesz użyć tego {0}, ponieważ masz nałożone ograniczenie czasowe!",
+			"noPermissionsBlacklist":"Nie możesz użyć tego {0}, ponieważ jesteś na czarnej liście!",
+			"noPermissionsLimitGlobal":"Nie możesz utworzyć ticketa, ponieważ serwer osiągnął maksymalny limit ticketów!",
+			"noPermissionsLimitGlobalUser":"Nie możesz utworzyć ticketa, ponieważ osiągnąłeś maksymalny limit ticketów!",
+			"noPermissionsLimitOption":"Nie możesz utworzyć ticketa, ponieważ serwer osiągnął maksymalny limit ticketów dla tej opcji!",
+			"noPermissionsLimitOptionUser":"Nie możesz utworzyć ticketa, ponieważ osiągnąłeś maksymalny limit ticketów dla tej opcji!",
+			"unknownTicket":"Spróbuj ponownie użyć tego polecenia w prawidłowym tickecie!",
+			"deprecatedTicket":"Obecny kanał nie jest prawidłowym ticketem! Może to być ticket z starej wersji Open Ticket!",
+			"notInGuild":"To {0} nie działa w DM! Spróbuj ponownie na serwerze!",
+			"channelRename":"Z powodu ograniczeń Discorda obecnie niemożliwe jest, aby bot zmienił nazwę kanału. Kanał zostanie automatycznie przemianowany w ciągu 10 minut, jeśli bot nie zostanie zrestartowany.",
+			"channelRenameSource":"Źródło tego błędu: {0}",
+			"busy":"Nie można użyć tego {0}!\nTicket jest obecnie przetwarzany przez bota.\n\nSpróbuj ponownie za kilka sekund!"
+		},
+		"optionInvalidReasons":{
+			"stringRegex":"Wartość nie pasuje do wzorca!",
+			"stringMinLength":"Wartość musi mieć co najmniej {0} znaków!",
+			"stringMaxLength":"Wartość może mieć maksymalnie {0} znaków!",
+			"numberInvalid":"Nieprawidłowa liczba!",
+			"numberMin":"Liczba musi wynosić co najmniej {0}!",
+			"numberMax":"Liczba może wynosić maksymalnie {0}!",
+			"numberDecimal":"Liczba nie może być dziesiętna!",
+			"numberNegative":"Liczba nie może być ujemna!",
+			"numberPositive":"Liczba nie może być dodatnia!",
+			"numberZero":"Liczba nie może wynosić zero!",
+			"channelNotFound":"Nie można znaleźć kanału!",
+			"userNotFound":"Nie można znaleźć użytkownika!",
+			"roleNotFound":"Nie można znaleźć roli!",
+			"memberNotFound":"Nie można znaleźć użytkownika!",
+			"mentionableNotFound":"Nie można znaleźć użytkownika ani roli!",
+			"channelType":"Nieprawidłowy typ kanału!",
+			"notInGuild":"Ta opcja wymaga, abyś był na serwerze!"
+		},
+		"permissions":{
+			"developer":"Musisz być deweloperem bota.",
+			"owner":"Musisz być właścicielem serwera.",
+			"admin":"Musisz być administratorem serwera.",
+			"moderator":"Musisz być moderatorem.",
+			"support":"Musisz należeć do zespołu wsparcia.",
+			"member":"Musisz być członkiem.",
+			"discord-administrator":"Musisz mieć uprawnienie `ADMINISTRATOR`."
+		},
+		"actionInvalid":{
+			"close":"Ticket jest już zamknięty!",
+			"reopen":"Ticket nie jest jeszcze zamknięty!",
+			"claim":"Ticket jest już przypisany!",
+			"unclaim":"Ticket nie jest jeszcze przypisany!",
+			"pin":"Ticket jest już przypięty!",
+			"unpin":"Ticket nie jest przypięty!",
+			"add":"Ten użytkownik już ma dostęp do ticketa!",
+			"remove":"Nie można usunąć tego użytkownika z ticketa!"
+		}
+	},
+    "params":{
+		"uppercase":{
+			"ticket":"Ticket",
+			"tickets":"Tickety",
+			"reason":"Powód",
+			"creator":"Twórca",
+			"remaining":"Pozostały czas",
+			"added":"Dodano",
+			"removed":"Usunięto",
+			"filter":"Filtr",
+			"claimedBy":"Przypisane przez {0}",
+			"method":"Metoda",
+			"type":"Typ",
+			"blacklisted":"Na czarnej liście",
+			"panel":"Panel",
+			"command":"Polecenie",
+			"system":"System",
+			"true":"Prawda",
+			"false":"Fałsz",
+			"syntax":"Składnia",
+			"originalName":"Oryginalna nazwa",
+			"newName":"Nowa nazwa",
+			"until":"Do",
+			"validOptions":"Prawidłowe opcje",
+			"validPanels":"Prawidłowe panele",
+			"autoclose":"Automatyczne zamknięcie",
+			"autodelete":"Automatyczne usunięcie",
+			"startupDate":"Data uruchomienia",
+			"version":"Wersja",
+			"name":"Nazwa",
+			"role":"Rola",
+			"status":"Status",
+			"claimed":"Przypisane",
+			"pinned":"Przypięte",
+			"creationDate":"Data utworzenia"
+		},
+		"lowercase":{
+			"text":"tekst",
+			"html":"html",
+			"command":"polecenie",
+			"modal":"modal",
+			"button":"przycisk",
+			"dropdown":"rozwijane menu",
+			"method":"metoda"
+		}
+	},
+	"commands":{
+		"reason":"Określ opcjonalny powód, który będzie widoczny w logach.",
+		"help":"Uzyskaj listę wszystkich dostępnych poleceń.",
+		"panel":"Wyślij wiadomość z rozwijanym menu lub przyciskami (do tworzenia ticketów).",
+		"panelId":"Identyfikator panelu, który chcesz wyświetlić.",
+		"panelAutoUpdate":"Czy chcesz, aby ten panel automatycznie aktualizował się po edycji?",
+		"ticket":"Natychmiast utwórz ticket.",
+		"ticketId":"Identyfikator ticketa, który chcesz utworzyć.",
+		"close":"Zamknij ticket.",
+		"delete":"Usuń ticket.",
+		"deleteNoTranscript":"Usuń ten ticket bez tworzenia transkryptu.",
+		"reopen":"Ponownie otwórz ticket.",
+		"claim":"Przypisz ticket.",
+		"claimUser":"Przypisz ten ticket innej osobie zamiast sobie.",
+		"unclaim":"Odpowiedz ticket.",
+		"pin":"Przypnij ticket.",
+		"unpin":"Odepnij ticket.",
+		"move":"Przenieś ticket.",
+		"moveId":"Identyfikator opcji, do której chcesz przenieść ticket.",
+		"rename":"Zmień nazwę ticketa.",
+		"renameName":"Nowa nazwa dla tego ticketa.",
+		"add":"Dodaj użytkownika do ticketa.",
+		"addUser":"Użytkownik do dodania.",
+		"remove":"Usuń użytkownika z ticketa.",
+		"removeUser":"Użytkownik do usunięcia.",
+		"blacklist":"Zarządzaj czarną listą ticketów.",
+		"blacklistView":"Wyświetl listę obecnej czarnej listy.",
+		"blacklistAdd":"Dodaj użytkownika do czarnej listy.",
+		"blacklistRemove":"Usuń użytkownika z czarnej listy.",
+		"blacklistGet":"Uzyskaj szczegóły użytkownika na czarnej liście.",
+		"blacklistGetUser":"Użytkownik do uzyskania szczegółów.",
+		"stats":"Wyświetl statystyki bota, użytkownika lub ticketa.",
+		"statsReset":"Zresetuj wszystkie statystyki bota (i zacznij liczyć od zera).",
+		"statsGlobal":"Wyświetl globalne statystyki.",
+		"statsUser":"Wyświetl statystyki użytkownika na serwerze.",
+		"statsUserUser":"Użytkownik do wyświetlenia.",
+		"statsTicket":"Wyświetl statystyki ticketa na serwerze.",
+		"statsTicketTicket":"Ticket do wyświetlenia.",
+		"clear":"Usuń wiele ticketów jednocześnie.",
+		"clearFilter":"Filtr do usuwania ticketów.",
+		"clearFilters":{
+			"all":"Wszystkie",
+			"open":"Otwarte",
+			"close":"Zamknięte",
+			"claim":"Przypisane",
+			"unclaim":"Nieprzypisane",
+			"pin":"Przypięte",
+			"unpin":"Nieprzypięte",
+			"autoclose":"Automatycznie zamknięte"
+		},
+		"autoclose":"Zarządzaj automatycznym zamknięciem ticketa.",
+		"autocloseDisable":"Wyłącz automatyczne zamknięcie w tym tickecie.",
+		"autocloseEnable":"Włącz automatyczne zamknięcie w tym tickecie.",
+		"autocloseEnableTime":"Liczba godzin braku aktywności potrzebna do zamknięcia ticketa.",
+		"autodelete":"Zarządzaj automatycznym usunięciem ticketa.",
+		"autodeleteDisable":"Wyłącz automatyczne usunięcie w tym tickecie.",
+		"autodeleteEnable":"Włącz automatyczne usunięcie w tym tickecie.",
+		"autodeleteEnableTime":"Liczba dni braku aktywności potrzebna do usunięcia ticketa."
+	},
+	"helpMenu":{
+		"help":"Uzyskaj listę wszystkich dostępnych poleceń.",
+		"ticket":"Natychmiast utwórz ticket.",
+		"close":"Zamknij ticket, wyłączając możliwość pisania na tym kanale.",
+		"delete":"Usuń ticket, tworząc transkrypt, jeśli jest włączony.",
+		"reopen":"Ponownie otwórz ticket, włączając możliwość pisania na tym kanale.",
+		"pin":"Przypnij ticket. To przeniesie ticket na górę i doda emoji '📌' do nazwy.",
+		"unpin":"Odepnij ticket. Ticket pozostanie na swojej pozycji, ale straci emoji '📌'.",
+		"move":"Przenieś ticket. To zmieni typ tego ticketa.",
+		"rename":"Zmień nazwę ticketa. To zmieni nazwę kanału tego ticketa.",
+		"claim":"Przypisz ticket. Dzięki temu możesz poinformować zespół, że zajmujesz się tym ticketem.",
+		"unclaim":"Odpowiedz ticket. Dzięki temu możesz poinformować zespół, że ticket jest ponownie dostępny.",
+		"add":"Dodaj użytkownika do ticketa. Pozwoli to użytkownikowi na odczyt i pisanie w tym tickecie.",
+		"remove":"Usuń użytkownika z ticketa. To odbierze użytkownikowi możliwość odczytu i pisania w tym tickecie.",
+		"panel":"Wyślij wiadomość z rozwijanym menu lub przyciskami (do tworzenia ticketów).",
+		"blacklistView":"Wyświetl listę obecnej czarnej listy.",
+		"blacklistAdd":"Dodaj użytkownika do czarnej listy.",
+		"blacklistRemove":"Usuń użytkownika z czarnej listy.",
+		"blacklistGet":"Uzyskaj szczegóły użytkownika na czarnej liście.",
+		"statsGlobal":"Wyświetl globalne statystyki.",
+		"statsTicket":"Wyświetl statystyki ticketa na serwerze.",
+		"statsUser":"Wyświetl statystyki użytkownika na serwerze.",
+		"statsReset":"Zresetuj wszystkie statystyki bota (i zacznij liczyć od zera).",
+		"autocloseDisable":"Wyłącz automatyczne zamknięcie w tym tickecie.",
+		"autocloseEnable":"Włącz automatyczne zamknięcie w tym tickecie.",
+		"autodeleteDisable":"Wyłącz automatyczne usunięcie w tym tickecie.",
+		"autodeleteEnable":"Włącz automatyczne usunięcie w tym tickecie."
+	},
+	"stats":{
+		"scopes":{
+			"global":"Globalne statystyki",
+			"system":"Statystyki systemu",
+			"user":"Statystyki użytkownika",
+			"ticket":"Statystyki ticketa",
+			"participants":"Uczestnicy"
+    },
+    "properties":{
+        "ticketsCreated":"Tickety utworzone",
+        "ticketsClosed":"Tickety zamknięte",
+        "ticketsDeleted":"Tickety usunięte",
+        "ticketsReopened":"Tickety ponownie otwarte",
+        "ticketsAutoclosed":"Tickety automatycznie zamknięte",
+        "ticketsClaimed":"Tickety przypisane",
+        "ticketsPinned":"Tickety przypięte",
+        "ticketsMoved":"Tickety przeniesione",
+        "usersBlacklisted":"Użytkownicy na czarnej liście",
+        "transcriptsCreated":"Transkrypty utworzone"
+		}
+	}
+}

languages/portuguese.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["quiradon"],
         "lastedited":"20/08/2024",
         "language":"Portuguese",

languages/romanian.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["SankeDev"],
         "lastedited":"27/08/2024",
         "language":"Romanian",

languages/russian.json

@@ -0,0 +1,465 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.3",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Russian",
+        "automated": true
+    },
+    "checker": {
+        "system": {
+            "typeError": "[ОШИБКА]",
+            "headerOpenTicket": "ОТКРЫТЬ ТИКЕТ",
+            "typeWarning": "[ПРЕДУПРЕЖДЕНИЕ]",
+            "typeInfo": "[ИНФОРМАЦИЯ]",
+            "headerConfigChecker": "ПРОВЕРКА КОНФИГУРАЦИИ",
+            "headerDescription": "проверьте наличие ошибок в ваших конфигурационных файлах!",
+            "footerError": "бот не запустится, пока все {0} не будут исправлены!",
+            "footerWarning": "рекомендуется исправить все {0} перед запуском!",
+            "footerSupport": "ПОДДЕРЖКА: {0} - ДОКУМЕНТАЦИЯ: {1}",
+            "compactInformation": "используйте {0} для получения дополнительной информации!",
+            "dataPath": "путь",
+            "dataDocs": "документация",
+            "dataMessages": "сообщение"
+        },
+        "messages": {
+            "stringTooShort": "Эта строка не может быть короче {0} символов!",
+            "stringTooLong": "Эта строка не может быть длиннее {0} символов!",
+            "stringLengthInvalid": "Эта строка должна быть длиной {0} символов!",
+            "stringStartsWith": "Эта строка должна начинаться с {0}!",
+            "stringEndsWith": "Эта строка должна заканчиваться на {0}!",
+            "stringContains": "Эта строка должна содержать {0}!",
+            "stringChoices": "Эта строка может быть только одним из следующих значений: {0}!",
+            "stringRegex": "Эта строка недействительна!",
+            "numberTooShort": "Это число не может быть короче {0} символов!",
+            "numberTooLong": "Это число не может быть длиннее {0} символов!",
+            "numberLengthInvalid": "Это число должно быть длиной {0} символов!",
+            "numberTooSmall": "Это число должно быть не менее {0}!",
+            "numberTooLarge": "Это число должно быть не более {0}!",
+            "numberNotEqual": "Это число должно быть {0}!",
+            "numberStep": "Это число должно быть кратным {0}!",
+            "numberStepOffset": "Это число должно быть кратным {0}, начиная с {1}!",
+            "numberStartsWith": "Это число должно начинаться с {0}!",
+            "numberEndsWith": "Это число должно заканчиваться на {0}!",
+            "numberContains": "Это число должно содержать {0}!",
+            "numberChoices": "Это число может быть только одним из следующих значений: {0}!",
+            "numberFloat": "Это число не может быть десятичным!",
+            "numberNegative": "Это число не может быть отрицательным!",
+            "numberPositive": "Это число не может быть положительным!",
+            "numberZero": "Это число не может быть нулем!",
+            "booleanTrue": "Это булево значение не может быть истинным!",
+            "booleanFalse": "Это булево значение не может быть ложным!",
+            "arrayEmptyDisabled": "Этот массив не может быть пустым!",
+            "arrayEmptyRequired": "Этот массив должен быть пустым!",
+            "arrayTooShort": "Этот массив должен иметь длину не менее {0}!",
+            "arrayTooLong": "Этот массив должен иметь длину не более {0}!",
+            "arrayLengthInvalid": "Этот массив должен иметь длину {0}!",
+            "arrayInvalidTypes": "Этот массив может содержать только следующие типы: {0}!",
+            "arrayDouble": "Этот массив не допускает повторяющихся значений!",
+            "discordInvalidId": "Это недействительный идентификатор {0} в Discord!",
+            "discordInvalidIdOptions": "Это недействительный идентификатор {0} в Discord! Вы также можете использовать один из следующих: {1}!",
+            "discordInvalidToken": "Это недействительный токен Discord (синтаксически)!",
+            "colorInvalid": "Это недействительный шестнадцатеричный цвет!",
+            "emojiTooShort": "Эта строка должна содержать не менее {0} эмодзи!",
+            "emojiTooLong": "Эта строка должна содержать не более {0} эмодзи!",
+            "emojiCustom": "Этот эмодзи не может быть пользовательским эмодзи Discord!",
+            "emojiInvalid": "Это недействительный эмодзи!",
+            "urlInvalid": "Этот URL недействителен!",
+            "urlInvalidHttp": "Этот URL может использовать только протокол https://!",
+            "urlInvalidProtocol": "Этот URL может использовать только протоколы http:// и https://!",
+            "urlInvalidHostname": "Этот URL имеет недопустимое имя хоста!",
+            "urlInvalidExtension": "Этот URL имеет недействительное расширение! Выберите из: {0}!",
+            "urlInvalidPath": "Этот URL имеет недействительный путь!",
+            "idNotUnique": "Этот идентификатор не уникален, используйте другой идентификатор!",
+            "idNonExistent": "Идентификатор {0} не существует!",
+            "invalidType": "Это свойство должно быть типа: {0}!",
+            "propertyMissing": "Свойство {0} отсутствует в этом объекте!",
+            "propertyOptional": "Свойство {0} необязательно в этом объекте!",
+            "objectDisabled": "Этот объект отключен, включите его с помощью {0}!",
+            "nullInvalid": "Это свойство не может быть null!",
+            "switchInvalidType": "Это должно быть одним из следующих типов: {0}!",
+            "objectSwitchInvalid": "Этот объект должен быть одним из следующих типов: {0}!",
+            "invalidLanguage": "Это недействительный язык!",
+            "invalidButton": "Эта кнопка должна иметь хотя бы {0} или {1}!",
+            "unusedOption": "Опция {0} нигде не используется!",
+            "unusedQuestion": "Вопрос {0} нигде не используется!",
+            "dropdownOption": "Панель с включенным выпадающим списком может содержать только опции типа 'ticket'!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Посетить тикет",
+            "close": "Закрыть тикет",
+            "delete": "Удалить тикет",
+            "reopen": "Переоткрыть тикет",
+            "claim": "Забрать тикет",
+            "unclaim": "Отказаться от тикета",
+            "pin": "Закрепить тикет",
+            "unpin": "Открепить тикет",
+            "clear": "Удалить тикеты",
+            "helpSwitchSlash": "Просмотреть слэш-команды",
+            "helpSwitchText": "Просмотреть текстовые команды",
+            "helpPage": "Страница {0}",
+            "withReason": "С причиной",
+            "withoutTranscript": "Без стенограммы"
+        },
+        "titles": {
+            "created": "Тикет создан",
+            "close": "Тикет закрыт",
+            "delete": "Тикет удален",
+            "reopen": "Тикет переоткрыт",
+            "claim": "Тикет забран",
+            "unclaim": "Тикет освобожден",
+            "pin": "Тикет закреплен",
+            "unpin": "Тикет откреплен",
+            "rename": "Тикет переименован",
+            "move": "Тикет перемещен",
+            "add": "Пользователь добавлен в тикет",
+            "remove": "Пользователь удален из тикета",
+            "help": "Доступные команды",
+            "statsReset": "Сбросить статистику",
+            "blacklistAdd": "Пользователь в черном списке",
+            "blacklistRemove": "Пользователь освобожден",
+            "blacklistGet": "Пользователь в черном списке",
+            "blacklistView": "Текущий черный список",
+            "blacklistAddDm": "Добавлен в черный список",
+            "blacklistRemoveDm": "Удален из черного списка",
+            "clear": "Тикеты очищены",
+            "roles": "Роли обновлены",
+            "autoclose": "Тикет автоматически закрыт",
+            "autocloseEnabled": "Автозакрытие включено",
+            "autocloseDisabled": "Автозакрытие отключено",
+            "autodelete": "Тикет автоматически удален",
+            "autodeleteEnabled": "Автоудаление включено",
+            "autodeleteDisabled": "Автоудаление отключено"
+        },
+        "descriptions": {
+            "create": "Ваш тикет был создан. Нажмите кнопку ниже, чтобы получить к нему доступ!",
+            "close": "Тикет был успешно закрыт!",
+            "delete": "Тикет был успешно удален!",
+            "reopen": "Тикет был успешно переоткрыт!",
+            "claim": "Тикет был успешно забран!",
+            "unclaim": "Тикет был успешно освобожден!",
+            "pin": "Тикет был успешно закреплен!",
+            "unpin": "Тикет был успешно откреплен!",
+            "rename": "Тикет был успешно переименован в {0}!",
+            "move": "Тикет был успешно перемещен в {0}!",
+            "add": "{0} был успешно добавлен в тикет!",
+            "remove": "{0} был успешно удален из тикета!",
+            "helpExplanation": "`<name>` => обязательный параметр\n`[name]` => необязательный параметр",
+            "statsReset": "Статистика бота была успешно сброшена!",
+            "statsError": "Невозможно просмотреть статистику тикета!\n{0} не является тикетом!",
+            "blacklistAdd": "{0} был успешно добавлен в черный список!",
+            "blacklistRemove": "{0} был успешно удален из черного списка!",
+            "blacklistGetSuccess": "{0} в настоящее время в черном списке!",
+            "blacklistGetEmpty": "{0} в настоящее время не в черном списке!",
+            "blacklistViewEmpty": "Никто еще не был добавлен в черный список!",
+            "blacklistViewTip": "Используйте \"/blacklist add\", чтобы добавить пользователя в черный список!",
+            "clearVerify": "Вы уверены, что хотите удалить несколько тикетов?\nЭто действие не может быть отменено!",
+            "clearReady": "{0} тикетов были успешно удалены!",
+            "rolesEmpty": "Ни одна роль не была обновлена!",
+            "autocloseLeave": "Этот тикет был автоматически закрыт, потому что создатель покинул сервер!",
+            "autocloseTimeout": "Этот тикет был автоматически закрыт, потому что он был неактивен более `{0}ч`!",
+            "autodeleteLeave": "Этот тикет был автоматически удален, потому что создатель покинул сервер!",
+            "autodeleteTimeout": "Этот тикет был автоматически удален, потому что он был неактивен более `{0} дней`!",
+            "autocloseEnabled": "Автозакрытие было включено для этого тикета!\nОн будет закрыт, если будет неактивен более `{0}ч`!",
+            "autocloseDisabled": "Автозакрытие было отключено для этого тикета!\nОн больше не будет закрываться автоматически!",
+            "autodeleteEnabled": "Автоудаление было включено для этого тикета!\nОн будет удален, если будет неактивен более `{0} дней`!",
+            "autodeleteDisabled": "Автоудаление было отключено для этого тикета!\nОн больше не будет удаляться автоматически!",
+            "ticketMessageLimit": "Вы можете создать только {0} тикет(ов) одновременно!",
+            "ticketMessageAutoclose": "Этот тикет будет автоматически закрыт, если будет неактивен {0}ч!",
+            "ticketMessageAutodelete": "Этот тикет будет автоматически удален, если будет неактивен {0} дней!",
+            "panelReady": "Вы можете найти панель ниже!\nЭто сообщение теперь можно удалить!"
+        },
+        "modal": {
+            "closePlaceholder": "Почему вы закрыли этот тикет?",
+            "deletePlaceholder": "Почему вы удалили этот тикет?",
+            "reopenPlaceholder": "Почему вы переоткрыли этот тикет?",
+            "claimPlaceholder": "Почему вы забрали этот тикет?",
+            "unclaimPlaceholder": "Почему вы отказались от этого тикета?",
+            "pinPlaceholder": "Почему вы закрепили этот тикет?",
+            "unpinPlaceholder": "Почему вы открепили этот тикет?"
+        },
+        "logs": {
+            "createLog": "Новый тикет был создан {0}!",
+            "closeLog": "Этот тикет был закрыт {0}!",
+            "closeDm": "Ваш тикет был закрыт на нашем сервере!",
+            "deleteLog": "Этот тикет был удален {0}!",
+            "deleteDm": "Ваш тикет был удален на нашем сервере!",
+            "reopenLog": "Этот тикет был переоткрыт {0}!",
+            "reopenDm": "Ваш тикет был переоткрыт на нашем сервере!",
+            "claimLog": "Этот тикет был забран {0}!",
+            "claimDm": "Ваш тикет был забран на нашем сервере!",
+            "unclaimLog": "Этот тикет был освобожден {0}!",
+            "unclaimDm": "Ваш тикет был освобожден на нашем сервере!",
+            "pinLog": "Этот тикет был закреплен {0}!",
+            "pinDm": "Ваш тикет был закреплен на нашем сервере!",
+            "unpinLog": "Этот тикет был откреплен {0}!",
+            "unpinDm": "Ваш тикет был откреплен на нашем сервере!",
+            "renameLog": "Этот тикет был переименован в {0} пользователем {1}!",
+            "renameDm": "Ваш тикет был переименован в {0} на нашем сервере!",
+            "moveLog": "Этот тикет был перемещен в {0} пользователем {1}!",
+            "moveDm": "Ваш тикет был перемещен в {0} на нашем сервере!",
+            "addLog": "{0} был добавлен в этот тикет пользователем {1}!",
+            "addDm": "{0} был добавлен в ваш тикет на нашем сервере!",
+            "removeLog": "{0} был удален из этого тикета пользователем {1}!",
+            "removeDm": "{0} был удален из вашего тикета на нашем сервере!",
+            "blacklistAddLog": "{0} был добавлен в черный список {1}!",
+            "blacklistRemoveLog": "{0} был удален из черного списка {1}!",
+            "blacklistAddDm": "Вы были добавлены в черный список на нашем сервере!\nОтныне вы не можете создавать тикеты!",
+            "blacklistRemoveDm": "Вы были удалены из черного списка на нашем сервере!\nТеперь вы снова можете создавать тикеты!",
+            "clearLog": "{0} тикетов были удалены {1}!"
+        }
+    },
+    "transcripts": {
+        "success": {
+            "visit": "Посетить стенограмму",
+            "ready": "Стенограмма создана",
+            "textFileDescription": "Это текстовая стенограмма удаленного тикета!",
+            "htmlProgress": "Пожалуйста, подождите, пока эта html-стенограмма обрабатывается...",
+            "createdChannel": "Новая {0} стенограмма была создана на сервере!",
+            "createdCreator": "Новая {0} стенограмма была создана для одного из ваших тикетов!",
+            "createdParticipant": "Новая {0} стенограмма была создана в одном из тикетов, в котором вы участвовали!",
+            "createdActiveAdmin": "Новая {0} стенограмма была создана в одном из тикетов, в котором вы участвовали как администратор!",
+            "createdEveryAdmin": "Новая {0} стенограмма была создана в одном из тикетов, в котором вы были администратором!",
+            "createdOther": "Новая {0} стенограмма была создана!"
+        },
+        "errors": {
+            "retry": "Повторить",
+            "continue": "Удалить без стенограммы",
+            "backup": "Создать резервную стенограмму",
+            "error": "Что-то пошло не так при попытке создать стенограмму.\nЧто вы хотите сделать?\n\nЭтот тикет не будет удален, пока вы не нажмете одну из этих кнопок."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Внутренняя ошибка",
+            "optionMissing": "Отсутствует опция команды",
+            "optionInvalid": "Недействительная опция команды",
+            "unknownCommand": "Неизвестная команда",
+            "noPermissions": "Нет разрешений",
+            "unknownTicket": "Неизвестный тикет",
+            "deprecatedTicket": "Устаревший тикет",
+            "unknownOption": "Неизвестная опция",
+            "unknownPanel": "Неизвестная панель",
+            "notInGuild": "Не на сервере",
+            "channelRename": "Невозможно переименовать канал",
+            "busy": "Тикет занят"
+        },
+        "descriptions": {
+            "askForInfo": "Свяжитесь с владельцем этого бота для получения дополнительной информации!",
+            "askForInfoResolve": "Свяжитесь с владельцем бота, если эта проблема не решится после нескольких попыток.",
+            "internalError": "Не удалось ответить на это {0} из-за внутренней ошибки!",
+            "optionMissing": "В этой команде отсутствует обязательный параметр!",
+            "optionInvalid": "Параметр в этой команде недействителен!",
+            "optionInvalidChoose": "Выберите из",
+            "unknownCommand": "Попробуйте посетить меню помощи для получения дополнительной информации!",
+            "noPermissions": "Вам не разрешено использовать это {0}!",
+            "noPermissionsList": "Требуемые разрешения: (одно из них)",
+            "noPermissionsCooldown": "Вам не разрешено использовать это {0}, потому что у вас есть перезарядка!",
+            "noPermissionsBlacklist": "Вам не разрешено использовать это {0}, потому что вы были добавлены в черный список!",
+            "noPermissionsLimitGlobal": "Вам не разрешено создавать тикет, потому что сервер достиг максимального предела тикетов!",
+            "noPermissionsLimitGlobalUser": "Вам не разрешено создавать тикет, потому что вы достигли максимального предела тикетов!",
+            "noPermissionsLimitOption": "Вам не разрешено создавать тикет, потому что сервер достиг максимального предела тикетов для этой опции!",
+            "noPermissionsLimitOptionUser": "Вам не разрешено создавать тикет, потому что вы достигли максимального предела тикетов для этой опции!",
+            "unknownTicket": "Попробуйте эту команду еще раз в действительном тикете!",
+            "deprecatedTicket": "Текущий канал не является действительным тикетом! Возможно, это был тикет из старой версии Open Ticket!",
+            "notInGuild": "Это {0} не работает в ЛС! Пожалуйста, попробуйте еще раз на сервере!",
+            "channelRename": "Из-за ограничений Discord на частоту запросов, боту сейчас невозможно переименовать канал. Канал будет автоматически переименован через 10 минут, если бот не будет перезагружен.",
+            "channelRenameSource": "Источник этой ошибки: {0}",
+            "busy": "Невозможно использовать это {0}!\nТикет в настоящее время обрабатывается ботом.\n\nПожалуйста, попробуйте еще раз через несколько секунд!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Значение не соответствует шаблону!",
+            "stringMinLength": "Значение должно быть не менее {0} символов!",
+            "stringMaxLength": "Значение должно быть не более {0} символов!",
+            "numberInvalid": "Недействительное число!",
+            "numberMin": "Число должно быть не менее {0}!",
+            "numberMax": "Число должно быть не более {0}!",
+            "numberDecimal": "Число не может быть десятичным!",
+            "numberNegative": "Число не может быть отрицательным!",
+            "numberPositive": "Число не может быть положительным!",
+            "numberZero": "Число не может быть нулем!",
+            "channelNotFound": "Невозможно найти канал!",
+            "userNotFound": "Невозможно найти пользователя!",
+            "roleNotFound": "Невозможно найти роль!",
+            "memberNotFound": "Невозможно найти пользователя!",
+            "mentionableNotFound": "Невозможно найти пользователя или роль!",
+            "channelType": "Недействительный тип канала!",
+            "notInGuild": "Для этой опции вам нужно быть на сервере!"
+        },
+        "permissions": {
+            "developer": "Вы должны быть разработчиком бота.",
+            "owner": "Вы должны быть владельцем сервера.",
+            "admin": "Вы должны быть администратором сервера.",
+            "moderator": "Вы должны быть модератором.",
+            "support": "Вы должны быть в команде поддержки.",
+            "member": "Вы должны быть участником.",
+            "discord-administrator": "У вас должно быть разрешение `ADMINISTRATOR`."
+        },
+        "actionInvalid": {
+            "close": "Тикет уже закрыт!",
+            "reopen": "Тикет еще не закрыт!",
+            "claim": "Тикет уже забран!",
+            "unclaim": "Тикет еще не забран!",
+            "pin": "Тикет уже закреплен!",
+            "unpin": "Тикет еще не закреплен!",
+            "add": "Этот пользователь уже имеет доступ к тикету!",
+            "remove": "Невозможно удалить этого пользователя из тикета!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Тикет",
+            "tickets": "Тикеты",
+            "reason": "Причина",
+            "creator": "Создатель",
+            "remaining": "Оставшееся время",
+            "added": "Добавлен",
+            "removed": "Удален",
+            "filter": "Фильтр",
+            "claimedBy": "Забран {0}",
+            "method": "Метод",
+            "type": "Тип",
+            "blacklisted": "В черном списке",
+            "panel": "Панель",
+            "command": "Команда",
+            "system": "Система",
+            "true": "Истина",
+            "false": "Ложь",
+            "syntax": "Синтаксис",
+            "originalName": "Исходное имя",
+            "newName": "Новое имя",
+            "until": "До",
+            "validOptions": "Действительные опции",
+            "validPanels": "Действительные панели",
+            "autoclose": "Автозакрытие",
+            "autodelete": "Автоудаление",
+            "startupDate": "Дата запуска",
+            "version": "Версия",
+            "name": "Имя",
+            "role": "Роль",
+            "status": "Статус",
+            "claimed": "Забран",
+            "pinned": "Закреплен",
+            "creationDate": "Дата создания"
+        },
+        "lowercase": {
+            "text": "текст",
+            "html": "html",
+            "command": "команда",
+            "modal": "модальное окно",
+            "button": "кнопка",
+            "dropdown": "выпадающий список",
+            "method": "метод"
+        }
+    },
+    "commands": {
+        "reason": "Укажите необязательную причину, которая будет видна в журналах.",
+        "help": "Получите список всех доступных команд.",
+        "panel": "Создайте сообщение с выпадающим списком или кнопками (для создания тикета).",
+        "panelId": "Идентификатор панели, которую вы хотите создать.",
+        "panelAutoUpdate": "Хотите ли вы, чтобы эта панель автоматически обновлялась при редактировании?",
+        "ticket": "Мгновенно создать тикет.",
+        "ticketId": "Идентификатор тикета, который вы хотите создать.",
+        "close": "Закрыть тикет.",
+        "delete": "Удалить тикет.",
+        "deleteNoTranscript": "Удалить этот тикет без создания стенограммы.",
+        "reopen": "Переоткрыть тикет.",
+        "claim": "Забрать тикет.",
+        "claimUser": "Забрать этот тикет для кого-то другого, а не для себя.",
+        "unclaim": "Отказаться от тикета.",
+        "pin": "Закрепить тикет.",
+        "unpin": "Открепить тикет.",
+        "move": "Переместить тикет.",
+        "moveId": "Идентификатор опции, в которую вы хотите переместить.",
+        "rename": "Переименовать тикет.",
+        "renameName": "Новое имя для этого тикета.",
+        "add": "Добавить пользователя в тикет.",
+        "addUser": "Пользователь, которого нужно добавить.",
+        "remove": "Удалить пользователя из тикета.",
+        "removeUser": "Пользователь, которого нужно удалить.",
+        "blacklist": "Управление черным списком тикетов.",
+        "blacklistView": "Просмотреть список текущего черного списка.",
+        "blacklistAdd": "Добавить пользователя в черный список.",
+        "blacklistRemove": "Удалить пользователя из черного списка.",
+        "blacklistGet": "Получить подробности о пользователе в черном списке.",
+        "blacklistGetUser": "Пользователь, о котором нужно получить подробности.",
+        "stats": "Просмотреть статистику бота, участника или тикета.",
+        "statsReset": "Сбросить всю статистику бота (и начать отсчет с нуля).",
+        "statsGlobal": "Просмотреть глобальную статистику.",
+        "statsUser": "Просмотреть статистику пользователя на сервере.",
+        "statsUserUser": "Пользователь для просмотра.",
+        "statsTicket": "Просмотреть статистику тикета на сервере.",
+        "statsTicketTicket": "Тикет для просмотра.",
+        "clear": "Удалить несколько тикетов одновременно.",
+        "clearFilter": "Фильтр для очистки тикетов.",
+        "clearFilters": {
+            "all": "Все",
+            "open": "Открытые",
+            "close": "Закрытые",
+            "claim": "Забранные",
+            "unclaim": "Не забранные",
+            "pin": "Закрепленные",
+            "unpin": "Не закрепленные",
+            "autoclose": "Автоматически закрытые"
+        },
+        "autoclose": "Управление автозакрытием в тикете.",
+        "autocloseDisable": "Отключить автозакрытие в этом тикете.",
+        "autocloseEnable": "Включить автозакрытие в этом тикете.",
+        "autocloseEnableTime": "Количество часов, в течение которых тикет должен быть неактивен, чтобы закрыть его.",
+        "autodelete": "Управление автоудалением в тикете.",
+        "autodeleteDisable": "Отключить автоудаление в этом тикете.",
+        "autodeleteEnable": "Включить автоудаление в этом тикете.",
+        "autodeleteEnableTime": "Количество дней, в течение которых тикет должен быть неактивен, чтобы удалить его."
+    },
+    "helpMenu": {
+        "help": "Получите список всех доступных команд.",
+        "ticket": "Мгновенно создать тикет.",
+        "close": "Закрыть тикет, это отключает запись в этом канале.",
+        "delete": "Удалить тикет, это создает стенограмму, если включено.",
+        "reopen": "Переоткрыть тикет, это снова включает запись в этом канале.",
+        "pin": "Закрепить тикет. Это переместит тикет наверх и добавит к имени эмодзи '📌'.",
+        "unpin": "Открепить тикет. Тикет останется на своем месте, но потеряет эмодзи '📌'.",
+        "move": "Переместить тикет. Это изменит тип этого тикета.",
+        "rename": "Переименовать тикет. Это изменит имя канала этого тикета.",
+        "claim": "Забрать тикет. С помощью этого вы можете сообщить своей команде, что вы обрабатываете этот тикет.",
+        "unclaim": "Отказаться от тикета. С помощью этого вы можете сообщить своей команде, что этот тикет снова свободен.",
+        "add": "Добавить пользователя в тикет. Это позволит пользователю читать и писать в этом тикете.",
+        "remove": "Удалить пользователя из тикета. Это удалит возможность читать и писать для пользователя в этом тикете.",
+        "panel": "Создайте сообщение с выпадающим списком или кнопками (для создания тикета).",
+        "blacklistView": "Просмотреть список текущего черного списка.",
+        "blacklistAdd": "Добавить пользователя в черный список.",
+        "blacklistRemove": "Удалить пользователя из черного списка.",
+        "blacklistGet": "Получить подробности о пользователе в черном списке.",
+        "statsGlobal": "Просмотреть глобальную статистику.",
+        "statsTicket": "Просмотреть статистику тикета на сервере.",
+        "statsUser": "Просмотреть статистику пользователя на сервере.",
+        "statsReset": "Сбросить всю статистику бота (и начать отсчет с нуля).",
+        "autocloseDisable": "Отключить автозакрытие в этом тикете.",
+        "autocloseEnable": "Включить автозакрытие в этом тикете.",
+        "autodeleteDisable": "Отключить автоудаление в этом тикете.",
+        "autodeleteEnable": "Включить автоудаление в этом тикете."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Глобальная статистика",
+            "system": "Статистика системы",
+            "user": "Статистика пользователя",
+            "ticket": "Статистика тикета",
+            "participants": "Участники"
+        },
+        "properties": {
+            "ticketsCreated": "Тикеты созданы",
+            "ticketsClosed": "Тикеты закрыты",
+            "ticketsDeleted": "Тикеты удалены",
+            "ticketsReopened": "Тикеты переоткрыты",
+            "ticketsAutoclosed": "Тикеты автоматически закрыты",
+            "ticketsClaimed": "Тикеты забраны",
+            "ticketsPinned": "Тикеты закреплены",
+            "ticketsMoved": "Тикеты перемещены",
+            "usersBlacklisted": "Пользователи в черном списке",
+            "transcriptsCreated": "Стенограммы созданы"
+        }
+    }
+}

languages/spanish.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["Redactado","Josuens"],
         "lastedited":"22/08/2024",
         "language":"Spanish",

languages/swedish.json

@@ -0,0 +1,478 @@
+{
+    "_TRANSLATION": {
+        "otversion": "v4.0.3",
+        "translators": ["NoOneNook"],
+        "lastedited": "25/03/2025",
+        "language": "Svenska",
+        "automated": false
+    },
+    "checker": {
+        "system": {
+            "typeError": "[FEL]",
+            "headerOpenTicket":"OPEN TICKET",
+            "typeWarning": "[VARNING]",
+            "typeInfo": "[INFO]",
+            "headerConfigChecker": "KONFIGURATIONSKONTROLL",
+            "headerDescription": "kontrollera efter fel i din konfiguration!",
+            "footerError": "botten startar inte förrän alla {0} är fixade!",
+            "footerWarning": "det rekommenderas att fixa alla {0} före start!",
+            "footerSupport": "SUPPORT: {0} - DOKUMENTATION: {1}",
+            "compactInformation": "använd {0} för mer information!",
+            "dataPath": "sökväg",
+            "dataDocs": "dokumentation",
+            "dataMessages": "meddelande"
+        },
+        "messages": {
+            "stringTooShort": "Denna sträng kan inte vara kortare än {0} tecken!",
+            "stringTooLong": "Denna sträng kan inte vara längre än {0} tecken!",
+            "stringLengthInvalid": "Denna sträng ska vara {0} tecken lång!",
+            "stringStartsWith": "Denna sträng ska börja med {0}!",
+            "stringEndsWith": "Denna sträng ska sluta med {0}!",
+            "stringContains": "Denna sträng ska innehålla {0}!",
+            "stringChoices": "Denna sträng kan endast vara en av följande värden: {0}!",
+            "stringRegex": "Denna sträng är ogiltig!",
+
+            "numberTooShort": "Detta tal kan inte vara kortare än {0} tecken!",
+            "numberTooLong": "Detta tal kan inte vara längre än {0} tecken!",
+            "numberLengthInvalid": "Detta tal ska vara {0} tecken långt!",
+            "numberTooSmall": "Detta tal ska vara minst {0}!",
+            "numberTooLarge": "Detta tal ska vara högst {0}!",
+            "numberNotEqual": "Detta tal ska vara {0}!",
+            "numberStep": "Detta tal ska vara en multipel av {0}!",
+            "numberStepOffset": "Detta tal ska vara en multipel av {0}, med start från {1}!",
+            "numberStartsWith": "Detta tal ska börja med {0}!",
+            "numberEndsWith": "Detta tal ska sluta med {0}!",
+            "numberContains": "Detta tal ska innehålla {0}!",
+            "numberChoices": "Detta tal kan endast vara en av följande värden: {0}!",
+            "numberFloat": "Detta tal kan inte vara ett decimaltal!",
+            "numberNegative": "Detta tal kan inte vara negativt!",
+            "numberPositive": "Detta tal kan inte vara positivt!",
+            "numberZero": "Detta tal kan inte vara noll!",
+
+            "booleanTrue": "Detta booleska värde kan inte vara sant!",
+            "booleanFalse": "Detta booleska värde kan inte vara falskt!",
+
+            "arrayEmptyDisabled": "Denna lista kan inte vara tom!",
+            "arrayEmptyRequired": "Denna lista ska vara tom!",
+            "arrayTooShort": "Denna lista ska ha en längd på minst {0}!",
+            "arrayTooLong": "Denna lista ska ha en längd på högst {0}!",
+            "arrayLengthInvalid": "Denna lista ska ha en längd på {0}!",
+            "arrayInvalidTypes": "Denna lista kan endast innehålla följande typer: {0}!",
+            "arrayDouble": "Denna lista tillåter inte samma värde två gånger!",
+
+            "discordInvalidId": "Detta är en ogiltig Discord {0} ID!",
+            "discordInvalidIdOptions": "Detta är en ogiltig Discord {0} ID! Du kan också använda en av dessa: {1}!",
+            "discordInvalidToken": "Detta är en ogiltig Discord-token (syntaktiskt)!",
+            "colorInvalid": "Detta är en ogiltig hexadecimal färg!",
+            "emojiTooShort": "Denna sträng ska ha minst {0} emojis!",
+            "emojiTooLong": "Denna sträng ska ha högst {0} emojis!",
+            "emojiCustom": "Denna emoji kan inte vara en anpassad Discord-emoji!",
+            "emojiInvalid": "Detta är en ogiltig emoji!",
+            "urlInvalid": "Denna URL är ogiltig!",
+            "urlInvalidHttp": "Denna URL kan endast använda https://-protokollet!",
+            "urlInvalidProtocol": "Denna URL kan endast använda http://- och https://-protokollen!",
+            "urlInvalidHostname": "Denna URL har ett otillåtet värdnamn!",
+            "urlInvalidExtension": "Denna URL har en ogiltig filtyp! Välj mellan: {0}!",
+            "urlInvalidPath": "Denna URL har en ogiltig sökväg!",
+            "idNotUnique": "Detta ID är inte unikt, använd ett annat ID istället!",
+            "idNonExistent": "ID {0} existerar inte!",
+
+            "invalidType": "Denna egenskap ska vara av typen: {0}!",
+            "propertyMissing": "Egenskapen {0} saknas i detta objekt!",
+            "propertyOptional": "Egenskapen {0} är valfri i detta objekt!",
+            "objectDisabled": "Detta objekt är inaktiverat, aktivera det genom att använda {0}!",
+            "nullInvalid": "Denna egenskap kan inte vara null!",
+            "switchInvalidType": "Detta ska vara en av följande typer: {0}!",
+            "objectSwitchInvalid": "Detta objekt ska vara en av följande typer: {0}!",
+
+            "invalidLanguage": "Detta är ett ogiltigt språk!",
+            "invalidButton": "Denna knapp ska ha minst en {0} eller {1}!",
+            "unusedOption": "Alternativet {0} används inte någonstans!",
+            "unusedQuestion": "Frågan {0} används inte någonstans!",
+            "dropdownOption": "Ett panel med dropdown aktiverad kan endast innehålla alternativ av typen 'ärende'!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Skapa Ärende",
+            "close": "Stäng Ärende",
+            "delete": "Radera Ärende",
+            "reopen": "Återöppna Ärende",
+            "claim": "Ta Ärende",
+            "unclaim": "Frigör Ärende",
+            "pin": "Fäst Ärende",
+            "unpin": "Lossa Ärende",
+            "clear": "Radera Ärenden",
+            "helpSwitchSlash": "Visa Slash-kommandon",
+            "helpSwitchText": "Visa Textkommandon",
+            "helpPage": "Sida {0}",
+            "withReason": "Med Orsak",
+            "withoutTranscript": "Utan Utskrift"
+        },
+        "titles": {
+            "created": "Ärende Skapat",
+            "close": "Ärende Stängt",
+            "delete": "Ärende Raderat",
+            "reopen": "Ärende Återöppnat",
+            "claim": "Ärende Taget",
+            "unclaim": "Ärende Frigjort",
+            "pin": "Ärende Fäst",
+            "unpin": "Ärende Lossat",
+            "rename": "Ärende Omdöpt",
+            "move": "Ärende Flyttat",
+            "add": "Användare Tillagd i Ärende",
+            "remove": "Användare Borttagen Från Ärende",
+
+            "help": "Tillgängliga Kommandon",
+            "statsReset": "Återställ Statistik",
+            "blacklistAdd": "Användare Svartlistad",
+            "blacklistRemove": "Användare Borttagen Från Svartlista",
+            "blacklistGet": "Svartlistad Användare",
+            "blacklistView": "Nuvarande Svartlista",
+            "blacklistAddDm": "Tillagd i Svartlista",
+            "blacklistRemoveDm": "Borttagen Från Svartlista",
+            "clear": "Ärenden Raderade",
+            "roles": "Roller Uppdaterade",
+
+            "autoclose": "Ärende Autostängt",
+            "autocloseEnabled": "Autostängning Aktiverad",
+            "autocloseDisabled": "Autostängning Inaktiverad",
+            "autodelete": "Ärende Autoraderat",
+            "autodeleteEnabled": "Autoradering Aktiverad",
+            "autodeleteDisabled": "Autoradering Inaktiverad"
+        },
+        "descriptions": {
+            "create": "Ditt ärende har skapats. Klicka på knappen nedan för att få tillgång till det!",
+            "close": "Ärendet har stängts framgångsrikt!",
+            "delete": "Ärendet har raderats framgångsrikt!",
+            "reopen": "Ärendet har återöppnats framgångsrikt!",
+            "claim": "Ärendet har tagits framgångsrikt!",
+            "unclaim": "Ärendet har frigjorts framgångsrikt!",
+            "pin": "Ärendet har fästs framgångsrikt!",
+            "unpin": "Ärendet har lossats framgångsrikt!",
+            "rename": "Ärendet har döpts om till {0} framgångsrikt!",
+            "move": "Ärendet har flyttats till {0} framgångsrikt!",
+            "add": "{0} har lagts till i ärendet framgångsrikt!",
+            "remove": "{0} har tagits bort från ärendet framgångsrikt!",
+
+            "helpExplanation": "`<namn>` => obligatorisk parameter\n`[namn]` => valfri parameter",
+            "statsReset": "Bottens statistik har återställts framgångsrikt!",
+            "statsError": "Kan inte visa ärendestatistik!\n{0} är inte ett ärende!",
+            "blacklistAdd": "{0} har svartlistats framgångsrikt!",
+            "blacklistRemove": "{0} har tagits bort från svartlistan framgångsrikt!",
+            "blacklistGetSuccess": "{0} är för närvarande svartlistad!",
+            "blacklistGetEmpty": "{0} är för närvarande inte svartlistad!",
+            "blacklistViewEmpty": "Ingen är svartlistad ännu!",
+            "blacklistViewTip": "Använd \"/blacklist add\" för att svartlista en användare!",
+            "clearVerify": "Är du säker på att du vill radera flera ärenden?\nDenna åtgärd kan inte ångras!",
+            "clearReady": "{0} ärenden har raderats framgångsrikt!",
+            "rolesEmpty": "Inga roller har uppdaterats!",
+
+            "autocloseLeave": "Detta ärende har autostängts eftersom skaparen lämnade servern!",
+            "autocloseTimeout": "Detta ärende har autostängts eftersom det har varit inaktivt i mer än `{0}t`!",
+            "autodeleteLeave": "Detta ärende har autoraderats eftersom skaparen lämnade servern!",
+            "autodeleteTimeout": "Detta ärende har autoraderats eftersom det har varit inaktivt i mer än `{0} dagar`!",
+            "autocloseEnabled": "Autostängning har aktiverats i detta ärende!\nDet kommer att stängas när det är inaktivt i mer än `{0}t`!",
+            "autocloseDisabled": "Autostängning har inaktiverats i detta ärende!\nDet kommer inte längre att stängas automatiskt!",
+            "autodeleteEnabled": "Autoradering har aktiverats i detta ärende!\nDet kommer att raderas när det är inaktivt i mer än `{0} dagar`!",
+            "autodeleteDisabled": "Autoradering har inaktiverats i detta ärende!\nDet kommer inte längre att raderas automatiskt!",
+
+            "ticketMessageLimit": "Du kan endast skapa {0} ärende(n) åt gången!",
+            "ticketMessageAutoclose": "Detta ärende kommer att autostängas när det är inaktivt i {0}t!",
+            "ticketMessageAutodelete": "Detta ärende kommer att autoraderas när det är inaktivt i {0} dagar!",
+            "panelReady": "Du hittar panelen nedan!\nDetta meddelande kan nu raderas!"
+        },
+        "modal": {
+            "closePlaceholder": "Varför stängde du detta ärende?",
+            "deletePlaceholder": "Varför raderade du detta ärende?",
+            "reopenPlaceholder": "Varför återöppnade du detta ärende?",
+            "claimPlaceholder": "Varför tog du detta ärende?",
+            "unclaimPlaceholder": "Varför frigjorde du detta ärende?",
+            "pinPlaceholder": "Varför fäste du detta ärende?",
+            "unpinPlaceholder": "Varför lossade du detta ärende?"
+        },
+        "logs": {
+            "createLog": "Ett nytt ärende har skapats av {0}!",
+            "closeLog": "Detta ärende har stängts av {0}!",
+            "closeDm": "Ditt ärende har stängts på vår server!",
+            "deleteLog": "Detta ärende har raderats av {0}!",
+            "deleteDm": "Ditt ärende har raderats på vår server!",
+            "reopenLog": "Detta ärende har återöppnats av {0}!",
+            "reopenDm": "Ditt ärende har återöppnats på vår server!",
+            "claimLog": "Detta ärende har tagits av {0}!",
+            "claimDm": "Ditt ärende har tagits på vår server!",
+            "unclaimLog": "Detta ärende har frigjorts av {0}!",
+            "unclaimDm": "Ditt ärende har frigjorts på vår server!",
+            "pinLog": "Detta ärende har fästs av {0}!",
+            "pinDm": "Ditt ärende har fästs på vår server!",
+            "unpinLog": "Detta ärende har lossats av {0}!",
+            "unpinDm": "Ditt ärende har lossats på vår server!",
+            "renameLog": "Detta ärende har döpts om till {0} av {1}!",
+            "renameDm": "Ditt ärende har döpts om till {0} på vår server!",
+            "moveLog": "Detta ärende har flyttats till {0} av {1}!",
+            "moveDm": "Ditt ärende har flyttats till {0} på vår server!",
+            "addLog": "{0} har lagts till i detta ärende av {1}!",
+            "addDm": "{0} har lagts till i ditt ärende på vår server!",
+            "removeLog": "{0} har tagits bort från detta ärende av {1}!",
+            "removeDm": "{0} har tagits bort från ditt ärende på vår server!",
+
+            "blacklistAddLog": "{0} har svartlistats av {1}!",
+            "blacklistRemoveLog": "{0} har tagits bort från svartlistan av {1}!",
+            "blacklistAddDm": "Du har svartlistats på vår server!\nFrån och med nu kan du inte skapa ett ärende!",
+            "blacklistRemoveDm": "Du har tagits bort från svartlistan på vår server!\nNu kan du skapa ärenden igen!",
+            "clearLog": "{0} ärenden har raderats av {1}!"
+        }
+    },
+    "transcripts": {
+        "success": {
+            "visit": "Besök Utskrift",
+            "ready": "Utskrift Skapad",
+            "textFileDescription": "Detta är textutskriften av ett raderat ärende!",
+            "htmlProgress": "Vänligen vänta medan denna HTML-utskrift bearbetas...",
+
+            "createdChannel": "En ny {0} utskrift har skapats på servern!",
+            "createdCreator": "En ny {0} utskrift har skapats för ett av dina ärenden!",
+            "createdParticipant": "En ny {0} utskrift har skapats i ett av ärendena du deltog i!",
+            "createdActiveAdmin": "En ny {0} utskrift har skapats i ett av ärendena du deltog i som admin!",
+            "createdEveryAdmin": "En ny {0} utskrift har skapats i ett av ärendena du var admin i!",
+            "createdOther": "En ny {0} utskrift har skapats!"
+        },
+        "errors": {
+            "retry": "Försök Igen",
+            "continue": "Radera Utan Utskrift",
+            "backup": "Skapa Säkerhetskopieringsutskrift",
+            "error": "Något gick fel vid försöket att skapa utskriften.\nVad vill du göra?\n\nDetta ärende kommer inte att raderas förrän du klickar på en av dessa knappar."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Internt Fel",
+            "optionMissing": "Kommandoalternativ Saknas",
+            "optionInvalid": "Ogiltigt Kommandoalternativ",
+            "unknownCommand": "Okänt Kommando",
+            "noPermissions": "Inga Behörigheter",
+            "unknownTicket": "Okänt Ärende",
+            "deprecatedTicket": "Utgånget Ärende",
+            "unknownOption": "Okänt Alternativ",
+            "unknownPanel": "Okänt Panel",
+            "notInGuild": "Inte På Server",
+            "channelRename": "Kan Inte Döpa Om Kanal",
+            "busy": "Ärendet Är Upptaget"
+        },
+        "descriptions": {
+            "askForInfo": "Kontakta ägaren av denna bot för mer information!",
+            "askForInfoResolve": "Kontakta ägaren av denna bot om problemet inte löser sig efter några försök!",
+            "internalError": "Kunde inte svara på denna {0} på grund av ett internt fel!",
+            "optionMissing": "En obligatorisk parameter saknas i detta kommando!",
+            "optionInvalid": "En parameter i detta kommando är ogiltig!",
+            "optionInvalidChoose": "Välj mellan",
+            "unknownCommand": "Försök besöka hjälpmenyn för mer information!",
+            "noPermissions": "Du har inte behörighet att använda denna {0}!",
+            "noPermissionsList": "Nödvändiga behörigheter: (en av dem)",
+            "noPermissionsCooldown": "Du har inte behörighet att använda denna {0} eftersom du har en nedkylningsperiod!",
+            "noPermissionsBlacklist": "Du har inte behörighet att använda denna {0} eftersom du är svartlistad!",
+            "noPermissionsLimitGlobal": "Du har inte behörighet att skapa ett ärende eftersom servern har nått maxgränsen för ärenden!",
+            "noPermissionsLimitGlobalUser": "Du har inte behörighet att skapa ett ärende eftersom du har nått maxgränsen för ärenden!",
+            "noPermissionsLimitOption": "Du har inte behörighet att skapa ett ärende eftersom servern har nått maxgränsen för detta alternativ!",
+            "noPermissionsLimitOptionUser": "Du har inte behörighet att skapa ett ärende eftersom du har nått maxgränsen för detta alternativ!",
+            "unknownTicket": "Försök med detta kommando igen i ett giltigt ärende!",
+            "deprecatedTicket": "Den nuvarande kanalen är inte ett giltigt ärende! Det kan ha varit ett ärende från en äldre version av Open Ticket!",
+            "notInGuild": "Denna {0} fungerar inte i DM! Försök igen på en server!",
+            "channelRename": "På grund av Discords hastighetsbegränsningar är det för närvarande omöjligt för botten att döpa om kanalen. Kanalen kommer automatiskt att döpas om inom 10 minuter om botten inte startas om.",
+            "channelRenameSource": "Källan till detta fel är: {0}",
+            "busy": "Kan inte använda denna {0}!\nÄrendet behandlas för närvarande av botten.\n\nFörsök igen om några sekunder!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Värdet matchar inte mönstret!",
+            "stringMinLength": "Värdet ska vara minst {0} tecken!",
+            "stringMaxLength": "Värdet ska vara högst {0} tecken!",
+            "numberInvalid": "Ogiltigt tal!",
+            "numberMin": "Talet ska vara minst {0}!",
+            "numberMax": "Talet ska vara högst {0}!",
+            "numberDecimal": "Talet kan inte vara ett decimaltal!",
+            "numberNegative": "Talet kan inte vara negativt!",
+            "numberPositive": "Talet kan inte vara positivt!",
+            "numberZero": "Talet kan inte vara noll!",
+            "channelNotFound": "Kan inte hitta kanalen!",
+            "userNotFound": "Kan inte hitta användaren!",
+            "roleNotFound": "Kan inte hitta rollen!",
+            "memberNotFound": "Kan inte hitta användaren!",
+            "mentionableNotFound": "Kan inte hitta användaren eller rollen!",
+            "channelType": "Ogiltig kanaltyp!",
+            "notInGuild": "Detta alternativ kräver att du är på en server!"
+        },
+        "permissions": {
+            "developer": "Du måste vara utvecklaren av botten.",
+            "owner": "Du måste vara serverägaren.",
+            "admin": "Du måste vara serveradministratör.",
+            "moderator": "Du måste vara moderator.",
+            "support": "Du måste vara en del av supportteamet.",
+            "member": "Du måste vara medlem.",
+            "discord-administrator": "Du måste ha `ADMINISTRATOR`-behörigheten."
+        },
+        "actionInvalid": {
+            "close": "Ärendet är redan stängt!",
+            "reopen": "Ärendet är inte stängt ännu!",
+            "claim": "Ärendet är redan taget!",
+            "unclaim": "Ärendet är inte taget ännu!",
+            "pin": "Ärendet är redan fäst!",
+            "unpin": "Ärendet är inte fäst ännu!",
+            "add": "Denna användare har redan tillgång till ärendet!",
+            "remove": "Kan inte ta bort denna användare från ärendet!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Ärende",
+            "tickets": "Ärenden",
+            "reason": "Orsak",
+            "creator": "Skapare",
+            "remaining": "Tid Kvar",
+            "added": "Tillagd",
+            "removed": "Borttagen",
+            "filter": "Filter",
+            "claimedBy": "Taget Av {0}",
+            "method": "Metod",
+            "type": "Typ",
+            "blacklisted": "Svartlistad",
+            "panel": "Panel",
+            "command": "Kommando",
+            "system": "System",
+            "true": "Sant",
+            "false": "Falskt",
+            "syntax": "Syntax",
+            "originalName": "Ursprungligt Namn",
+            "newName": "Nytt Namn",
+            "until": "Till",
+            "validOptions": "Giltiga Alternativ",
+            "validPanels": "Giltiga Paneler",
+            "autoclose": "Autostängning",
+            "autodelete": "Autoradering",
+            "startupDate": "Startdatum",
+            "version": "Version",
+            "name": "Namn",
+            "role": "Roll",
+            "status": "Status",
+            "claimed": "Taget",
+            "pinned": "Fäst",
+            "creationDate": "Skapelsedatum"
+        },
+        "lowercase": {
+            "text": "text",
+            "html": "html",
+            "command": "kommando",
+            "modal": "modal",
+            "button": "knapp",
+            "dropdown": "rullgardinsmeny",
+            "method": "metod"
+        }
+    },
+    "commands": {
+        "reason": "Ange en valfri orsak som kommer att vara synlig i loggarna.",
+        "help": "Få en lista över alla tillgängliga kommandon.",
+        "panel": "Skapa ett meddelande med en rullgardinsmeny eller knappar (för ärendeskapande).",
+        "panelId": "Identifieraren för panelen du vill skapa.",
+        "panelAutoUpdate": "Vill du att denna panel ska uppdateras automatiskt när den redigeras?",
+        "ticket": "Skapa ett ärende direkt.",
+        "ticketId": "Identifieraren för ärendet du vill skapa.",
+        "close": "Stäng ett ärende.",
+        "delete": "Radera ett ärende.",
+        "deleteNoTranscript": "Radera detta ärende utan att skapa en utskrift.",
+        "reopen": "Återöppna ett ärende.",
+        "claim": "Ta ett ärende.",
+        "claimUser": "Ta detta ärende för en annan användare istället för dig själv.",
+        "unclaim": "Frigör ett ärende.",
+        "pin": "Fäst ett ärende.",
+        "unpin": "Lossa ett ärende.",
+        "move": "Flytta ett ärende.",
+        "moveId": "Identifieraren för alternativet du vill flytta till.",
+        "rename": "Döp om ett ärende.",
+        "renameName": "Det nya namnet på detta ärende.",
+        "add": "Lägg till en användare i ett ärende.",
+        "addUser": "Användaren som ska läggas till.",
+        "remove": "Ta bort en användare från ett ärende.",
+        "removeUser": "Användaren som ska tas bort.",
+        "blacklist": "Hantera svartlistan för ärenden.",
+        "blacklistView": "Visa en lista över nuvarande svartlista.",
+        "blacklistAdd": "Lägg till en användare på svartlistan.",
+        "blacklistRemove": "Ta bort en användare från svartlistan.",
+        "blacklistGet": "Hämta detaljer om en svartlistad användare.",
+        "blacklistGetUser": "Användaren att hämta detaljer från.",
+        "stats": "Visa statistik från botten, en användare eller ett ärende.",
+        "statsReset": "Återställ all statistik för botten (och börja räkna från noll).",
+        "statsGlobal": "Visa global statistik.",
+        "statsUser": "Visa statistik från en användare på servern.",
+        "statsUserUser": "Användaren som ska visas.",
+        "statsTicket": "Visa statistik för ett ärende på servern.",
+        "statsTicketTicket": "Ärendet som ska visas.",
+        "clear": "Radera flera ärenden samtidigt.",
+        "clearFilter": "Filtret för att radera ärenden.",
+        "clearFilters": {
+            "all": "Alla",
+            "open": "Öppna",
+            "close": "Stängda",
+            "claim": "Tagna",
+            "unclaim": "Frigjorda",
+            "pin": "Fästa",
+            "unpin": "Lossade",
+            "autoclose": "Autostängda"
+        },
+        "autoclose": "Hantera autostängning i ett ärende.",
+        "autocloseDisable": "Inaktivera autostängning i detta ärende.",
+        "autocloseEnable": "Aktivera autostängning i detta ärende.",
+        "autocloseEnableTime": "Antal timmar detta ärende måste vara inaktivt innan det stängs.",
+        "autodelete": "Hantera autoradering i ett ärende.",
+        "autodeleteDisable": "Inaktivera autoradering i detta ärende.",
+        "autodeleteEnable": "Aktivera autoradering i detta ärende.",
+        "autodeleteEnableTime": "Antal dagar detta ärende måste vara inaktivt innan det raderas."
+    },
+    "helpMenu": {
+        "help": "Få en lista över alla tillgängliga kommandon.",
+        "ticket": "Skapa ett ärende direkt.",
+        "close": "Stäng ett ärende, detta inaktiverar skrivning i kanalen.",
+        "delete": "Radera ett ärende, detta skapar en utskrift när det är aktiverat.",
+        "reopen": "Återöppna ett ärende, detta aktiverar skrivning i kanalen igen.",
+        "pin": "Fäst ett ärende. Detta flyttar ärendet till toppen och lägger till en '📌' emoji i namnet.",
+        "unpin": "Lossa ett ärende. Ärendet blir kvar på plats, men förlorar '📌' emojin.",
+        "move": "Flytta ett ärende. Detta ändrar typen på ärendet.",
+        "rename": "Döp om ett ärende. Detta ändrar kanalnamnet på ärendet.",
+        "claim": "Ta ett ärende. Detta låter ditt team veta att du hanterar ärendet.",
+        "unclaim": "Frigör ett ärende. Detta låter ditt team veta att ärendet är ledigt igen.",
+        "add": "Lägg till en användare i ett ärende. Detta ger användaren tillgång att läsa och skriva i ärendet.",
+        "remove": "Ta bort en användare från ett ärende. Detta tar bort användarens tillgång att läsa och skriva i ärendet.",
+        "panel": "Skapa ett meddelande med en rullgardinsmeny eller knappar (för ärendeskapande).",
+        "blacklistView": "Visa en lista över nuvarande svartlista.",
+        "blacklistAdd": "Lägg till en användare på svartlistan.",
+        "blacklistRemove": "Ta bort en användare från svartlistan.",
+        "blacklistGet": "Hämta detaljer om en svartlistad användare.",
+        "statsGlobal": "Visa global statistik.",
+        "statsTicket": "Visa statistik för ett ärende på servern.",
+        "statsUser": "Visa statistik från en användare på servern.",
+        "statsReset": "Återställ all statistik för botten (och börja räkna från noll).",
+        "autocloseDisable": "Inaktivera autostängning i detta ärende.",
+        "autocloseEnable": "Aktivera autostängning i detta ärende.",
+        "autodeleteDisable": "Inaktivera autoradering i detta ärende.",
+        "autodeleteEnable": "Aktivera autoradering i detta ärende."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Global Statistik",
+            "system": "Systemstatistik",
+            "user": "Användarstatistik",
+            "ticket": "Ärendestatistik",
+            "participants": "Deltagare"
+        },
+        "properties": {
+            "ticketsCreated": "Ärenden Skapade",
+            "ticketsClosed": "Ärenden Stängda",
+            "ticketsDeleted": "Ärenden Raderade",
+            "ticketsReopened": "Ärenden Återöppnade",
+            "ticketsAutoclosed": "Ärenden Autostängda",
+            "ticketsClaimed": "Ärenden Tagna",
+            "ticketsPinned": "Ärenden Fästa",
+            "ticketsMoved": "Ärenden Flyttade",
+            "usersBlacklisted": "Användare Svartlistade",
+            "transcriptsCreated": "Utskrifter Skapade"
+        }
+    }
+}

languages/thai.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["modshd"],
         "lastedited":"13/11/2024",
         "language":"Thai",

languages/turkish.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION": {
-        "otversion": "v4.0.0",
+        "otversion": "v4.0.3",
         "translators": ["palestinian"],
         "lastedited": "26/11/2024",
         "language": "Turkish",

languages/ukrainian.json

@@ -1,6 +1,6 @@
 {
     "_TRANSLATION":{
-        "otversion":"v4.0.0",
+        "otversion":"v4.0.3",
         "translators":["Anderskiy"],
         "lastedited":"31/08/2024",
         "language":"Ukrainian",

languages/vietnamese.json

@@ -0,0 +1,466 @@
+{
+    "_TRANSLATION":{
+        "otversion":"v4.0.3",
+        "translators":["ngocdiep2006"],
+        "lastedited":"07/04/2025",
+        "language":"Vietnamese",
+        "automated":true
+    },
+    "checker":{
+        "system":{
+            "typeError":"[ERROR]",
+            "headerOpenTicket":"OPEN TICKET",
+            "typeWarning":"[WARNING]",
+            "typeInfo":"[INFO]",
+            "headerConfigChecker":"CONFIG CHECKER",
+            "headerDescription":"check for errors in your config files!",
+            "footerError":"the bot won't start until all {0}'s are fixed!",
+            "footerWarning":"it's recommended to fix all {0}'s before starting!",
+            "footerSupport":"SUPPORT: {0} - DOCS: {1}",
+            "compactInformation":"use {0} for more information!",
+            "dataPath":"path",
+            "dataDocs":"docs",
+            "dataMessages":"message"
+        },
+       "messages": {
+            "stringTooShort": "Chuỗi này không thể ngắn hơn {0} ký tự!",
+            "stringTooLong": "Chuỗi này không thể dài hơn {0} ký tự!",
+            "stringLengthInvalid": "Chuỗi này cần dài {0} ký tự!",
+            "stringStartsWith": "Chuỗi này cần bắt đầu bằng {0}!",
+            "stringEndsWith": "Chuỗi này cần kết thúc bằng {0}!",
+            "stringContains": "Chuỗi này cần chứa {0}!",
+            "stringChoices": "Chuỗi này chỉ có thể là một trong các giá trị sau: {0}!",
+            "stringRegex": "Chuỗi này không hợp lệ!",
+            "numberTooShort": "Số này không thể ngắn hơn {0} ký tự!",
+            "numberTooLong": "Số này không thể dài hơn {0} ký tự!",
+            "numberLengthInvalid": "Số này cần dài {0} ký tự!",
+            "numberTooSmall": "Số này cần ít nhất là {0}!",
+            "numberTooLarge": "Số này cần nhiều nhất là {0}!",
+            "numberNotEqual": "Số này cần là {0}!",
+            "numberStep": "Số này cần là bội số của {0}!",
+            "numberStepOffset": "Số này cần là bội số của {0} bắt đầu từ {1}!",
+            "numberStartsWith": "Số này cần bắt đầu bằng {0}!",
+            "numberEndsWith": "Số này cần kết thúc bằng {0}!",
+            "numberContains": "Số này cần chứa {0}!",
+            "numberChoices": "Số này chỉ có thể là một trong các giá trị sau: {0}!",
+            "numberFloat": "Số này không thể là số thập phân!",
+            "numberNegative": "Số này không thể là số âm!",
+            "numberPositive": "Số này không thể là số dương!",
+            "numberZero": "Số này không thể là số không!",
+            "booleanTrue": "Boolean này không thể là true!",
+            "booleanFalse": "Boolean này không thể là false!",
+            "arrayEmptyDisabled": "Mảng này không được phép rỗng!",
+            "arrayEmptyRequired": "Mảng này bắt buộc phải rỗng!",
+            "arrayTooShort": "Mảng này cần có độ dài ít nhất là {0}!",
+            "arrayTooLong": "Mảng này cần có độ dài nhiều nhất là {0}!",
+            "arrayLengthInvalid": "Mảng này cần có độ dài là {0}!",
+            "arrayInvalidTypes": "Mảng này chỉ có thể chứa các kiểu sau: {0}!",
+            "arrayDouble": "Mảng này không cho phép giá trị trùng lặp!",
+            "discordInvalidId": "Đây là id discord {0} không hợp lệ!",
+            "discordInvalidIdOptions": "Đây là id discord {0} không hợp lệ! Bạn cũng có thể sử dụng một trong những id sau: {1}!",
+            "discordInvalidToken": "Đây là token discord không hợp lệ (về mặt cú pháp)!",
+            "colorInvalid": "Đây là màu hex không hợp lệ!",
+            "emojiTooShort": "Chuỗi này cần có ít nhất {0} emoji!",
+            "emojiTooLong": "Chuỗi này cần có nhiều nhất {0} emoji!",
+            "emojiCustom": "Emoji này không thể là emoji discord tùy chỉnh!",
+            "emojiInvalid": "Đây là emoji không hợp lệ!",
+            "urlInvalid": "URL này không hợp lệ!",
+            "urlInvalidHttp": "URL này chỉ có thể sử dụng giao thức https://!",
+            "urlInvalidProtocol": "URL này chỉ có thể sử dụng giao thức http:// & https://!",
+            "urlInvalidHostname": "URL này có tên máy chủ bị cấm!",
+            "urlInvalidExtension": "URL này có phần mở rộng không hợp lệ! Chọn trong số: {0}!",
+            "urlInvalidPath": "URL này có đường dẫn không hợp lệ!",
+            "idNotUnique": "ID này không duy nhất, hãy sử dụng ID khác!",
+            "idNonExistent": "ID {0} không tồn tại!",
+            "invalidType": "Thuộc tính này cần có kiểu: {0}!",
+            "propertyMissing": "Thuộc tính {0} bị thiếu trong đối tượng này!",
+            "propertyOptional": "Thuộc tính {0} là tùy chọn trong đối tượng này!",
+            "objectDisabled": "Đối tượng này bị tắt, hãy bật nó bằng cách sử dụng {0}!",
+            "nullInvalid": "Thuộc tính này không thể là null!",
+            "switchInvalidType": "Điều này cần là một trong các kiểu sau: {0}!",
+            "objectSwitchInvalid": "Đối tượng này cần là một trong các kiểu sau: {0}!",
+            "invalidLanguage": "Đây là ngôn ngữ không hợp lệ!",
+            "invalidButton": "Nút này cần có ít nhất một {0} hoặc {1}!",
+            "unusedOption": "Tùy chọn {0} không được sử dụng ở bất kỳ đâu!",
+            "unusedQuestion": "Câu hỏi {0} không được sử dụng ở bất kỳ đâu!",
+            "dropdownOption": "Bảng điều khiển có bật dropdown chỉ có thể chứa các tùy chọn thuộc loại 'ticket'!"
+        }
+    },
+    "actions": {
+        "buttons": {
+            "create": "Truy cập Ticket",
+            "close": "Đóng Ticket",
+            "delete": "Xóa Ticket",
+            "reopen": "Mở lại Ticket",
+            "claim": "Nhận Ticket",
+            "unclaim": "Bỏ nhận Ticket",
+            "pin": "Ghim Ticket",
+            "unpin": "Bỏ ghim Ticket",
+            "clear": "Xóa Tickets",
+            "helpSwitchSlash": "Xem Lệnh Slash",
+            "helpSwitchText": "Xem Lệnh Văn Bản",
+            "helpPage": "Trang {0}",
+            "withReason": "Có Lý Do",
+            "withoutTranscript": "Không Có Bản Ghi"
+        },
+        "titles": {
+            "created": "Ticket Đã Tạo",
+            "close": "Ticket Đã Đóng",
+            "delete": "Ticket Đã Xóa",
+            "reopen": "Ticket Đã Mở Lại",
+            "claim": "Ticket Đã Nhận",
+            "unclaim": "Ticket Đã Bỏ Nhận",
+            "pin": "Ticket Đã Ghim",
+            "unpin": "Ticket Đã Bỏ Ghim",
+            "rename": "Ticket Đã Đổi Tên",
+            "move": "Ticket Đã Di Chuyển",
+            "add": "Người Dùng Đã Thêm Vào Ticket",
+            "remove": "Người Dùng Đã Xóa Khỏi Ticket",
+            "help": "Lệnh Có Sẵn",
+            "statsReset": "Đặt Lại Thống Kê",
+            "blacklistAdd": "Người Dùng Đã Bị Cấm",
+            "blacklistRemove": "Người Dùng Đã Được Gỡ Cấm",
+            "blacklistGet": "Người Dùng Bị Cấm",
+            "blacklistView": "Danh Sách Cấm Hiện Tại",
+            "blacklistAddDm": "Đã Thêm Vào Danh Sách Cấm",
+            "blacklistRemoveDm": "Đã Xóa Khỏi Danh Sách Cấm",
+            "clear": "Tickets Đã Xóa",
+            "roles": "Vai Trò Đã Cập Nhật",
+            "autoclose": "Ticket Tự Động Đóng",
+            "autocloseEnabled": "Tự Động Đóng Đã Bật",
+            "autocloseDisabled": "Tự Động Đóng Đã Tắt",
+            "autodelete": "Ticket Tự Động Xóa",
+            "autodeleteEnabled": "Tự Động Xóa Đã Bật",
+            "autodeleteDisabled": "Tự Động Xóa Đã Tắt"
+        },
+        "descriptions": {
+            "create": "Ticket của bạn đã được tạo. Nhấp vào nút bên dưới để truy cập!",
+            "close": "Ticket đã được đóng thành công!",
+            "delete": "Ticket đã được xóa thành công!",
+            "reopen": "Ticket đã được mở lại thành công!",
+            "claim": "Ticket đã được nhận thành công!",
+            "unclaim": "Ticket đã được bỏ nhận thành công!",
+            "pin": "Ticket đã được ghim thành công!",
+            "unpin": "Ticket đã được bỏ ghim thành công!",
+            "rename": "Ticket đã được đổi tên thành {0} thành công!",
+            "move": "Ticket đã được di chuyển đến {0} thành công!",
+            "add": "{0} đã được thêm vào ticket thành công!",
+            "remove": "{0} đã được xóa khỏi ticket thành công!",
+            "helpExplanation": "`<name>` => tham số bắt buộc\n`[name]` => tham số tùy chọn",
+            "statsReset": "Thống kê bot đã được đặt lại thành công!",
+            "statsError": "Không thể xem thống kê ticket!\n{0} không phải là ticket!",
+            "blacklistAdd": "{0} đã bị cấm thành công!",
+            "blacklistRemove": "{0} đã được gỡ cấm thành công!",
+            "blacklistGetSuccess": "{0} hiện đang bị cấm!",
+            "blacklistGetEmpty": "{0} hiện không bị cấm!",
+            "blacklistViewEmpty": "Chưa có ai bị cấm!",
+            "blacklistViewTip": "Sử dụng \"/blacklist add\" để cấm người dùng!",
+            "clearVerify": "Bạn có chắc chắn muốn xóa nhiều ticket không?\nHành động này không thể hoàn tác!",
+            "clearReady": "{0} tickets đã được xóa thành công!",
+            "rolesEmpty": "Không có vai trò nào được cập nhật!",
+            "autocloseLeave": "Ticket này đã được tự động đóng vì người tạo đã rời khỏi máy chủ!",
+            "autocloseTimeout": "Ticket này đã được tự động đóng vì không hoạt động quá `{0}h`!",
+            "autodeleteLeave": "Ticket này đã được tự động xóa vì người tạo đã rời khỏi máy chủ!",
+            "autodeleteTimeout": "Ticket này đã được tự động xóa vì không hoạt động quá `{0} ngày`!",
+            "autocloseEnabled": "Tự động đóng đã được bật trong ticket này!\nNó sẽ được đóng khi không hoạt động quá `{0}h`!",
+            "autocloseDisabled": "Tự động đóng đã được tắt trong ticket này!\nNó sẽ không tự động đóng nữa!",
+            "autodeleteEnabled": "Tự động xóa đã được bật trong ticket này!\nNó sẽ được xóa khi không hoạt động quá `{0} ngày`!",
+            "autodeleteDisabled": "Tự động xóa đã được tắt trong ticket này!\nNó sẽ không tự động xóa nữa!",
+            "ticketMessageLimit": "Bạn chỉ có thể tạo {0} ticket cùng lúc!",
+            "ticketMessageAutoclose": "Ticket này sẽ được tự động đóng khi không hoạt động trong {0}h!",
+            "ticketMessageAutodelete": "Ticket này sẽ được tự động xóa khi không hoạt động trong {0} ngày!",
+            "panelReady": "Bạn có thể tìm thấy bảng điều khiển bên dưới!\nThông báo này có thể được xóa ngay bây giờ!"
+        }
+,
+        "modal": {
+            "closePlaceholder": "Tại sao bạn đóng ticket này?",
+            "deletePlaceholder": "Tại sao bạn xóa ticket này?",
+            "reopenPlaceholder": "Tại sao bạn mở lại ticket này?",
+            "claimPlaceholder": "Tại sao bạn nhận ticket này?",
+            "unclaimPlaceholder": "Tại sao bạn bỏ nhận ticket này?",
+            "pinPlaceholder": "Tại sao bạn ghim ticket này?",
+            "unpinPlaceholder": "Tại sao bạn bỏ ghim ticket này?"
+        },
+        "logs": {
+            "createLog": "Một ticket mới đã được tạo bởi {0}!",
+            "closeLog": "Ticket này đã được đóng bởi {0}!",
+            "closeDm": "Ticket của bạn đã được đóng trong máy chủ của chúng tôi!",
+            "deleteLog": "Ticket này đã được xóa bởi {0}!",
+            "deleteDm": "Ticket của bạn đã được xóa trong máy chủ của chúng tôi!",
+            "reopenLog": "Ticket này đã được mở lại bởi {0}!",
+            "reopenDm": "Ticket của bạn đã được mở lại trong máy chủ của chúng tôi!",
+            "claimLog": "Ticket này đã được nhận bởi {0}!",
+            "claimDm": "Ticket của bạn đã được nhận trong máy chủ của chúng tôi!",
+            "unclaimLog": "Ticket này đã được bỏ nhận bởi {0}!",
+            "unclaimDm": "Ticket của bạn đã được bỏ nhận trong máy chủ của chúng tôi!",
+            "pinLog": "Ticket này đã được ghim bởi {0}!",
+            "pinDm": "Ticket của bạn đã được ghim trong máy chủ của chúng tôi!",
+            "unpinLog": "Ticket này đã được bỏ ghim bởi {0}!",
+            "unpinDm": "Ticket của bạn đã được bỏ ghim trong máy chủ của chúng tôi!",
+            "renameLog": "Ticket này đã được đổi tên thành {0} bởi {1}!",
+            "renameDm": "Ticket của bạn đã được đổi tên thành {0} trong máy chủ của chúng tôi!",
+            "moveLog": "Ticket này đã được di chuyển đến {0} bởi {1}!",
+            "moveDm": "Ticket của bạn đã được di chuyển đến {0} trong máy chủ của chúng tôi!",
+            "addLog": "{0} đã được thêm vào ticket này bởi {1}!",
+            "addDm": "{0} đã được thêm vào ticket của bạn trong máy chủ của chúng tôi!",
+            "removeLog": "{0} đã được xóa khỏi ticket này bởi {1}!",
+            "removeDm": "{0} đã được xóa khỏi ticket của bạn trong máy chủ của chúng tôi!",
+            "blacklistAddLog": "{0} đã bị cấm bởi {1}!",
+            "blacklistRemoveLog": "{0} đã được gỡ khỏi danh sách cấm bởi {1}!",
+            "blacklistAddDm": "Bạn đã bị cấm trong máy chủ của chúng tôi!\nTừ bây giờ, bạn không thể tạo ticket!",
+            "blacklistRemoveDm": "Bạn đã được gỡ khỏi danh sách cấm trong máy chủ của chúng tôi!\nBây giờ bạn có thể tạo lại ticket!",
+            "clearLog": "{0} tickets đã được xóa bởi {1}!"
+        }
+    },
+    "transcripts": {
+        "success": {
+            "visit": "Truy Cập Bản Ghi",
+            "ready": "Bản Ghi Đã Tạo",
+            "textFileDescription": "Đây là bản ghi văn bản của một ticket đã xóa!",
+            "htmlProgress": "Vui lòng đợi trong khi bản ghi html này đang được xử lý...",
+            "createdChannel": "Một bản ghi {0} mới đã được tạo trong máy chủ!",
+            "createdCreator": "Một bản ghi {0} mới đã được tạo cho một trong các ticket của bạn!",
+            "createdParticipant": "Một bản ghi {0} mới đã được tạo trong một trong các ticket bạn tham gia!",
+            "createdActiveAdmin": "Một bản ghi {0} mới đã được tạo trong một trong các ticket bạn tham gia với tư cách quản trị viên!",
+            "createdEveryAdmin": "Một bản ghi {0} mới đã được tạo trong một trong các ticket bạn là quản trị viên!",
+            "createdOther": "Một bản ghi {0} mới đã được tạo!"
+        },
+        "errors": {
+            "retry": "Thử Lại",
+            "continue": "Xóa Không Có Bản Ghi",
+            "backup": "Tạo Bản Ghi Dự Phòng",
+            "error": "Đã xảy ra lỗi khi cố gắng tạo bản ghi.\nBạn muốn làm gì?\n\nTicket này sẽ không bị xóa cho đến khi bạn nhấp vào một trong các nút này."
+        }
+    },
+    "errors": {
+        "titles": {
+            "internalError": "Lỗi Nội Bộ",
+            "optionMissing": "Thiếu Tùy Chọn Lệnh",
+            "optionInvalid": "Tùy Chọn Lệnh Không Hợp Lệ",
+            "unknownCommand": "Lệnh Không Xác Định",
+            "noPermissions": "Không Có Quyền",
+            "unknownTicket": "Ticket Không Xác Định",
+            "deprecatedTicket": "Ticket Đã Lỗi Thời",
+            "unknownOption": "Tùy Chọn Không Xác Định",
+            "unknownPanel": "Bảng Điều Khiển Không Xác Định",
+            "notInGuild": "Không Ở Trong Máy Chủ",
+            "channelRename": "Không Thể Đổi Tên Kênh",
+            "busy": "Ticket Đang Bận"
+        },
+        "descriptions": {
+            "askForInfo": "Liên hệ với chủ sở hữu của bot này để biết thêm thông tin!",
+            "askForInfoResolve": "Liên hệ với chủ sở hữu bot này nếu vấn đề này không được giải quyết sau vài lần thử.",
+            "internalError": "Không thể phản hồi {0} này do lỗi nội bộ!",
+            "optionMissing": "Thiếu tham số bắt buộc trong lệnh này!",
+            "optionInvalid": "Tham số trong lệnh này không hợp lệ!",
+            "optionInvalidChoose": "Chọn trong số",
+            "unknownCommand": "Hãy thử truy cập menu trợ giúp để biết thêm thông tin!",
+            "noPermissions": "Bạn không được phép sử dụng {0} này!",
+            "noPermissionsList": "Quyền Bắt Buộc: (một trong số chúng)",
+            "noPermissionsCooldown": "Bạn không được phép sử dụng {0} này vì bạn đang trong thời gian chờ!",
+            "noPermissionsBlacklist": "Bạn không được phép sử dụng {0} này vì bạn đã bị cấm!",
+            "noPermissionsLimitGlobal": "Bạn không được phép tạo ticket vì máy chủ đã đạt đến giới hạn ticket tối đa!",
+            "noPermissionsLimitGlobalUser": "Bạn không được phép tạo ticket vì bạn đã đạt đến giới hạn ticket tối đa!",
+            "noPermissionsLimitOption": "Bạn không được phép tạo ticket vì máy chủ đã đạt đến giới hạn ticket tối đa cho tùy chọn này!",
+            "noPermissionsLimitOptionUser": "Bạn không được phép tạo ticket vì bạn đã đạt đến giới hạn ticket tối đa cho tùy chọn này!",
+            "unknownTicket": "Hãy thử lại lệnh này trong một ticket hợp lệ!",
+            "deprecatedTicket": "Kênh hiện tại không phải là ticket hợp lệ! Nó có thể là một ticket từ phiên bản Open Ticket cũ!",
+            "notInGuild": "{0} này không hoạt động trong DM! Vui lòng thử lại trong máy chủ!",
+            "channelRename": "Do giới hạn tốc độ của discord, hiện tại bot không thể đổi tên kênh. Kênh sẽ tự động được đổi tên trong 10 phút nếu bot không được khởi động lại.",
+            "channelRenameSource": "Nguồn gốc của lỗi này là: {0}",
+            "busy": "Không thể sử dụng {0} này!\nTicket hiện đang được bot xử lý.\n\nVui lòng thử lại sau vài giây!"
+        },
+        "optionInvalidReasons": {
+            "stringRegex": "Giá trị không khớp với mẫu!",
+            "stringMinLength": "Giá trị cần có ít nhất {0} ký tự!",
+            "stringMaxLength": "Giá trị cần có nhiều nhất {0} ký tự!",
+            "numberInvalid": "Số không hợp lệ!",
+            "numberMin": "Số cần ít nhất là {0}!",
+            "numberMax": "Số cần nhiều nhất là {0}!",
+            "numberDecimal": "Số không được phép là số thập phân!",
+            "numberNegative": "Số không được phép là số âm!",
+            "numberPositive": "Số không được phép là số dương!",
+            "numberZero": "Số không được phép là số không!",
+            "channelNotFound": "Không thể tìm thấy kênh!",
+            "userNotFound": "Không thể tìm thấy người dùng!",
+            "roleNotFound": "Không thể tìm thấy vai trò!",
+            "memberNotFound": "Không thể tìm thấy người dùng!",
+            "mentionableNotFound": "Không thể tìm thấy người dùng hoặc vai trò!",
+            "channelType": "Loại kênh không hợp lệ!",
+            "notInGuild": "Tùy chọn này yêu cầu bạn phải ở trong máy chủ!"
+        },
+        "permissions": {
+            "developer": "Bạn cần là nhà phát triển của bot.",
+            "owner": "Bạn cần là chủ sở hữu máy chủ.",
+            "admin": "Bạn cần là quản trị viên máy chủ.",
+            "moderator": "Bạn cần là người điều hành.",
+            "support": "Bạn cần ở trong nhóm hỗ trợ.",
+            "member": "Bạn cần là thành viên.",
+            "discord-administrator": "Bạn cần có quyền `ADMINISTRATOR`."
+        },
+        "actionInvalid": {
+            "close": "Ticket đã đóng!",
+            "reopen": "Ticket chưa đóng!",
+            "claim": "Ticket đã được nhận!",
+            "unclaim": "Ticket chưa được nhận!",
+            "pin": "Ticket đã được ghim!",
+            "unpin": "Ticket chưa được ghim!",
+            "add": "Người dùng này đã có thể truy cập ticket!",
+            "remove": "Không thể xóa người dùng này khỏi ticket!"
+        }
+    },
+    "params": {
+        "uppercase": {
+            "ticket": "Ticket",
+            "tickets": "Tickets",
+            "reason": "Lý Do",
+            "creator": "Người Tạo",
+            "remaining": "Thời Gian Còn Lại",
+            "added": "Đã Thêm",
+            "removed": "Đã Xóa",
+            "filter": "Bộ Lọc",
+            "claimedBy": "Được Nhận Bởi {0}",
+            "method": "Phương Pháp",
+            "type": "Loại",
+            "blacklisted": "Bị Cấm",
+            "panel": "Bảng Điều Khiển",
+            "command": "Lệnh",
+            "system": "Hệ Thống",
+            "true": "Đúng",
+            "false": "Sai",
+            "syntax": "Cú Pháp",
+            "originalName": "Tên Gốc",
+            "newName": "Tên Mới",
+            "until": "Đến",
+            "validOptions": "Tùy Chọn Hợp Lệ",
+            "validPanels": "Bảng Điều Khiển Hợp Lệ",
+            "autoclose": "Tự Động Đóng",
+            "autodelete": "Tự Động Xóa",
+            "startupDate": "Ngày Khởi Động",
+            "version": "Phiên Bản",
+            "name": "Tên",
+            "role": "Vai Trò",
+            "status": "Trạng Thái",
+            "claimed": "Đã Nhận",
+            "pinned": "Đã Ghim",
+            "creationDate": "Ngày Tạo"
+        },
+        "lowercase": {
+            "text": "văn bản",
+            "html": "html",
+            "command": "lệnh",
+            "modal": "modal",
+            "button": "nút",
+            "dropdown": "dropdown",
+            "method": "phương pháp"
+        }
+    },
+    "commands": {
+        "reason": "Chỉ định lý do tùy chọn sẽ hiển thị trong nhật ký.",
+        "help": "Nhận danh sách tất cả các lệnh có sẵn.",
+        "panel": "Tạo thông báo có dropdown hoặc nút (để tạo ticket).",
+        "panelId": "Mã định danh của bảng điều khiển bạn muốn tạo.",
+        "panelAutoUpdate": "Bạn có muốn bảng điều khiển này tự động cập nhật khi được chỉnh sửa không?",
+        "ticket": "Tạo ticket ngay lập tức.",
+        "ticketId": "Mã định danh của ticket bạn muốn tạo.",
+        "close": "Đóng ticket.",
+        "delete": "Xóa ticket.",
+        "deleteNoTranscript": "Xóa ticket này mà không tạo bản ghi.",
+        "reopen": "Mở lại ticket.",
+        "claim": "Nhận ticket.",
+        "claimUser": "Nhận ticket này cho người khác thay vì chính bạn.",
+        "unclaim": "Bỏ nhận ticket.",
+        "pin": "Ghim ticket.",
+        "unpin": "Bỏ ghim ticket.",
+        "move": "Di chuyển ticket.",
+        "moveId": "Mã định danh của tùy chọn bạn muốn di chuyển đến.",
+        "rename": "Đổi tên ticket.",
+        "renameName": "Tên mới cho ticket này.",
+        "add": "Thêm người dùng vào ticket.",
+        "addUser": "Người dùng cần thêm.",
+        "remove": "Xóa người dùng khỏi ticket.",
+        "removeUser": "Người dùng cần xóa.",
+        "blacklist": "Quản lý danh sách cấm ticket.",
+        "blacklistView": "Xem danh sách cấm hiện tại.",
+        "blacklistAdd": "Thêm người dùng vào danh sách cấm.",
+        "blacklistRemove": "Xóa người dùng khỏi danh sách cấm.",
+        "blacklistGet": "Nhận thông tin chi tiết từ người dùng bị cấm.",
+        "blacklistGetUser": "Người dùng cần nhận thông tin chi tiết.",
+        "stats": "Xem thống kê từ bot, thành viên hoặc ticket.",
+        "statsReset": "Đặt lại tất cả thống kê của bot (và bắt đầu đếm từ không).",
+        "statsGlobal": "Xem thống kê toàn cầu.",
+        "statsUser": "Xem thống kê từ người dùng trong máy chủ.",
+        "statsUserUser": "Người dùng cần xem.",
+        "statsTicket": "Xem thống kê của ticket trong máy chủ.",
+        "statsTicketTicket": "Ticket cần xem.",
+        "clear": "Xóa nhiều ticket cùng lúc.",
+        "clearFilter": "Bộ lọc để xóa ticket.",
+        "clearFilters": {
+            "all": "Tất Cả",
+            "open": "Mở",
+            "close": "Đã Đóng",
+            "claim": "Đã Nhận",
+            "unclaim": "Chưa Nhận",
+            "pin": "Đã Ghim",
+            "unpin": "Chưa Ghim",
+            "autoclose": "Tự Động Đóng"
+        },
+        "autoclose": "Quản lý tự động đóng trong ticket.",
+        "autocloseDisable": "Tắt tự động đóng trong ticket này.",
+        "autocloseEnable": "Bật tự động đóng trong ticket này.",
+        "autocloseEnableTime": "Số giờ ticket này cần không hoạt động để đóng.",
+        "autodelete": "Quản lý tự động xóa trong ticket.",
+        "autodeleteDisable": "Tắt tự động xóa trong ticket này.",
+        "autodeleteEnable": "Bật tự động xóa trong ticket này.",
+        "autodeleteEnableTime": "Số ngày ticket này cần không hoạt động để xóa."
+    },
+    "helpMenu": {
+        "help": "Nhận danh sách tất cả các lệnh có sẵn.",
+        "ticket": "Tạo ticket ngay lập tức.",
+        "close": "Đóng ticket, điều này vô hiệu hóa việc viết trong kênh này.",
+        "delete": "Xóa ticket, điều này tạo bản ghi khi được bật.",
+        "reopen": "Mở lại ticket, điều này cho phép viết lại trong kênh này.",
+        "pin": "Ghim ticket. Điều này sẽ di chuyển ticket lên đầu và thêm biểu tượng cảm xúc '📌' vào tên.",
+        "unpin": "Bỏ ghim ticket. Ticket sẽ giữ nguyên vị trí nhưng sẽ mất biểu tượng cảm xúc '📌'.",
+        "move": "Di chuyển ticket. Điều này sẽ thay đổi loại ticket này.",
+        "rename": "Đổi tên ticket. Điều này sẽ thay đổi tên kênh của ticket này.",
+        "claim": "Nhận ticket. Với điều này, bạn có thể cho nhóm của mình biết bạn đang xử lý ticket này.",
+        "unclaim": "Bỏ nhận ticket. Với điều này, bạn có thể cho nhóm của mình biết rằng ticket này lại rảnh.",
+        "add": "Thêm người dùng vào ticket. Điều này sẽ cho phép người dùng đọc và viết trong ticket này.",
+        "remove": "Xóa người dùng khỏi ticket. Điều này sẽ xóa khả năng đọc và viết của người dùng trong ticket này.",
+        "panel": "Tạo thông báo có dropdown hoặc nút (để tạo ticket).",
+        "blacklistView": "Xem danh sách cấm hiện tại.",
+        "blacklistAdd": "Thêm người dùng vào danh sách cấm.",
+        "blacklistRemove": "Xóa người dùng khỏi danh sách cấm.",
+        "blacklistGet": "Nhận thông tin chi tiết từ người dùng bị cấm.",
+        "statsGlobal": "Xem thống kê toàn cầu.",
+        "statsTicket": "Xem thống kê của ticket trong máy chủ.",
+        "statsUser": "Xem thống kê từ người dùng trong máy chủ.",
+        "statsReset": "Đặt lại tất cả thống kê của bot (và bắt đầu đếm từ không).",
+        "autocloseDisable": "Tắt tự động đóng trong ticket này.",
+        "autocloseEnable": "Bật tự động đóng trong ticket này.",
+        "autodeleteDisable": "Tắt tự động xóa trong ticket này.",
+        "autodeleteEnable": "Bật tự động xóa trong ticket này."
+    },
+    "stats": {
+        "scopes": {
+            "global": "Thống Kê Toàn Cầu",
+            "system": "Thống Kê Hệ Thống",
+            "user": "Thống Kê Người Dùng",
+            "ticket": "Thống Kê Ticket",
+            "participants": "Người Tham Gia"
+        },
+        "properties": {
+            "ticketsCreated": "Tickets Đã Tạo",
+            "ticketsClosed": "Tickets Đã Đóng",
+            "ticketsDeleted": "Tickets Đã Xóa",
+            "ticketsReopened": "Tickets Đã Mở Lại",
+            "ticketsAutoclosed": "Tickets Tự Động Đóng",
+            "ticketsClaimed": "Tickets Đã Nhận",
+            "ticketsPinned": "Tickets Đã Ghim",
+            "ticketsMoved": "Tickets Đã Di Chuyển",
+            "usersBlacklisted": "Người Dùng Bị Cấm",
+            "transcriptsCreated": "Bản Ghi Đã Tạo"
+        }
+    }
+}

package.json

@@ -1,7 +1,7 @@
 {
     "name": "open-ticket",
     "author": "DJdj Development",
-    "version": "4.0.0",
+    "version": "4.0.3",
     "description": "The most advanced open-source discord ticket bot with HTML transcripts, plugins, questions, claiming, pinning & more! Using discord.js v14 & JSON database! ",
     "keywords": [
         "ticket-bot",
@@ -16,24 +16,34 @@
         "start": "node index.js",
         "startnc": "node index.js --no-compile",
         "test": "node index.js --dev-config --dev-database",
-        "testnc": "node index.js --no-compile --dev-config --dev-database"
+        "testnc": "node index.js --no-compile --dev-config --dev-database",
+        "docs": "npx typedoc --options .docs/typedoc-config.json && node .docs/createDocs.js"
     },
     "type": "commonjs",
     "license": "GPL-3.0-only",
     "dependencies": {
+        "@discordjs/rest": "^2.4.2",
         "@types/node": "^22.5.0",
         "ansis": "^2.3.0",
-        "discord.js": "^14.16.1",
+        "discord.js": "^14.19.1",
         "formatted-json-stringify": "^1.1.0",
         "typescript": "^5.5.4"
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/DJj123dj/open-ticket.git"
+        "url": "git+https://github.com/open-discord-bots/open-ticket.git"
     },
     "bugs": {
-        "url": "https://github.com/DJj123dj/open-ticket/issues",
+        "url": "https://github.com/open-discord-bots/open-ticket/issues",
         "email": "support@dj-dj.be"
     },
-    "homepage": "https://openticket.dj-dj.be"
+    "homepage": "https://openticket.dj-dj.be",
+    "imports": {
+        "#opendiscord": "./dist/src/index.js",
+        "#opendiscord-types": "./dist/src/core/api/api.js"
+    },
+    "funding": {
+        "type": "individual",
+        "url": "https://github.com/sponsors/DJj123dj"
+    }
 }

plugins/example-plugin/index.ts

@@ -1,4 +1,4 @@
-import {api, openticket, utilities} from "../../src/index"
+import {api, opendiscord, utilities} from "#opendiscord"
 import * as discord from "discord.js"
 
 /////////////////////////////////////////////
@@ -7,17 +7,19 @@ import * as discord from "discord.js"
 /////////////////////////////////////////////
 
 if (utilities.project != "openticket") throw new api.ODPluginError("This plugin only works in Open Ticket!")
-if (!utilities.isBeta) throw new api.ODPluginError("This plugin is made for the beta version of Open Ticket!")
 
 //Add Typescript autocomplete support for plugin data. (!!!OPTIONAL!!!)
-declare module "../../src/core/api/api.js" {
+declare module "#opendiscord-types" {
+    export interface ODPluginManagerIds_Default {
+        "example-plugin":api.ODPlugin
+    }
     export interface ODConfigManagerIds_Default {
         "example-plugin:config":api.ODJsonConfig
     }
 }
 
 //Let's register the example config. This way it's available for all plugins & systems.
-openticket.events.get("onConfigLoad").listen((configManager) => {
+opendiscord.events.get("onConfigLoad").listen((configManager) => {
     configManager.add(new api.ODJsonConfig("example-plugin:config","config.json","./plugins/example-plugin/"))
     /*===== What did we do? =====
     - "example-plugin:config" Is the ID of this config. You can use this id troughout the bot to access this config file. Even in other plugins.
@@ -27,18 +29,18 @@ openticket.events.get("onConfigLoad").listen((configManager) => {
 
     //Let's also log it to the console to let us know it worked!
     const ourConfig = configManager.get("example-plugin:config")
-    openticket.log("The example config loaded successfully!","plugin",[
+    opendiscord.log("The example config loaded successfully!","plugin",[
         {key:"var-1",value:ourConfig.data.testVariable1},
         {key:"var-2",value:ourConfig.data.testVariable2.toString()},
         {key:"var-3",value:ourConfig.data.testVariable3.toString()}
     ])
 })
 
-openticket.events.get("onTicketCreate").listen((creator) => {
+opendiscord.events.get("onTicketCreate").listen((creator) => {
     //This is logged before the ticket is created (after the button is pressed)
-    openticket.log("Ticket is getting created...","plugin")
+    opendiscord.log("Ticket is getting created...","plugin")
 })
-openticket.events.get("afterTicketCreated").listen((ticket,creator,channel) => {
+opendiscord.events.get("afterTicketCreated").listen((ticket,creator,channel) => {
     //This is logged after the ticket is created
-    openticket.log("Ticket ready!","plugin")
+    opendiscord.log("Ticket ready!","plugin")
 })

plugins/example-plugin/plugin.json

@@ -8,7 +8,7 @@
     "priority":0,
     "events":[],
 
-    "npmDependencies":["discord.js"],
+    "npmDependencies":[],
     "requiredPlugins":[],
     "incompatiblePlugins":[],
 

src/actions/addTicketUser.ts

@@ -1,24 +1,24 @@
 ///////////////////////////////////////
 //TICKET ADD USER SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:add-ticket-user"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:add-ticket-user"))
-    openticket.actions.get("openticket:add-ticket-user").workers.add([
+    opendiscord.actions.get("opendiscord:add-ticket-user").workers.add([
-        new api.ODWorker("openticket:add-ticket-user",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:add-ticket-user",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to add user to ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketUserAdd").emit([ticket,user,data,channel,reason])
+            await opendiscord.events.get("onTicketUserAdd").emit([ticket,user,data,channel,reason])
             
             //update ticket
-            ticket.get("openticket:participants").value.push({type:"user",id:data.id})
+            ticket.get("opendiscord:participants").value.push({type:"user",id:data.id})
-            ticket.get("openticket:participants").refreshDatabase()
+            ticket.get("opendiscord:participants").refreshDatabase()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //update channel permissions
             try{
@@ -31,46 +31,47 @@ export const registerActions = async () => {
                     ReadMessageHistory:true
                 })
             }catch{
-                openticket.log("Failed to add channel permission overwrites on add-ticket-user","error")
+                opendiscord.log("Failed to add channel permission overwrites on add-ticket-user","error")
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket user adding!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket user adding!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value,hidden:true}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:add-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:add-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketUserAdded").emit([ticket,user,data,channel,reason])
+            await opendiscord.events.get("afterTicketUserAdded").emit([ticket,user,data,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.adding.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.adding.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.adding.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"add",reason,additionalData:data}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket,data} = params
 
-            openticket.log(user.displayName+" added "+data.displayName+" to a ticket!","info",[
+            opendiscord.log(user.displayName+" added "+data.displayName+" to a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -80,8 +81,8 @@ export const registerActions = async () => {
             ])
         })
     ])
-    openticket.actions.get("openticket:add-ticket-user").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:add-ticket-user").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/actions/claimTicket.ts

@@ -1,85 +1,88 @@
 ///////////////////////////////////////
 //TICKET CLAIMING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:claim-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:claim-ticket"))
-    openticket.actions.get("openticket:claim-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:claim-ticket").workers.add([
-        new api.ODWorker("openticket:claim-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to claim ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketClaim").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketClaim").emit([ticket,user,channel,reason])
             
             //update ticket
-            ticket.get("openticket:claimed").value = true
+            ticket.get("opendiscord:claimed").value = true
-            ticket.get("openticket:claimed-by").value = user.id
+            ticket.get("opendiscord:claimed-by").value = user.id
-            ticket.get("openticket:claimed-on").value = new Date().getTime()
+            ticket.get("opendiscord:claimed-on").value = new Date().getTime()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-claimed",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-claimed",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-claimed",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-claimed",user.id,1,"increase")
 
             //update category
-            const rawClaimCategory = ticket.option.get("openticket:channel-categories-claimed").value.find((c) => c.user == user.id)
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
-            const claimCategory = (rawClaimCategory) ? rawClaimCategory.category : null
+                const rawClaimCategory = ticket.option.get("opendiscord:channel-categories-claimed").value.find((c) => c.user == user.id)
-            if (claimCategory){
+                const claimCategory = (rawClaimCategory) ? rawClaimCategory.category : null
-                try {
+                if (claimCategory){
-                    channel.setParent(claimCategory,{lockPermissions:false})
+                    try {
-                    ticket.get("openticket:category-mode").value = "claimed"
+                        channel.setParent(claimCategory,{lockPermissions:false})
-                    ticket.get("openticket:category").value = claimCategory
+                        ticket.get("opendiscord:category-mode").value = "claimed"
-                }catch(e){
+                        ticket.get("opendiscord:category").value = claimCategory
-                    openticket.log("Unable to move ticket to 'claimed category'!","error",[
+                    }catch(e){
-                        {key:"channel",value:"#"+channel.name},
+                        opendiscord.log("Unable to move ticket to 'claimed category'!","error",[
-                        {key:"channelid",value:channel.id,hidden:true},
+                            {key:"channel",value:"#"+channel.name},
-                        {key:"categoryid",value:claimCategory}
+                            {key:"channelid",value:channel.id,hidden:true},
-                    ])
+                            {key:"categoryid",value:claimCategory}
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    }
                 }
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket claiming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket claiming!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:claim-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketClaimed").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketClaimed").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.claiming.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.claiming.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.claiming.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"claim",reason,additionalData:null}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" claimed a ticket!","info",[
+            opendiscord.log(user.displayName+" claimed a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -89,188 +92,188 @@ export const registerActions = async () => {
             ])
         })
     ])
-    openticket.actions.get("openticket:claim-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:claim-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }
 
 export const registerVerifyBars = async () => {
     //CLAIM TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:claim-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:claim-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:claim-ticket-ticket-message").success.add([
+    opendiscord.verifybars.get("opendiscord:claim-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.claim
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already claimed
-            if (ticket.get("openticket:claimed").value){
+            if (ticket.get("opendiscord:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start claiming ticket
             if (params.data == "reason"){
                 //claim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:claim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:claim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
             }else{
                 //claim without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:claim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:claim-ticket-ticket-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:claim-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 
     //CLAIM TICKET UNCLAIM MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:claim-ticket-unclaim-message",openticket.builders.messages.getSafe("openticket:verifybar-unclaim-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:claim-ticket-unclaim-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-unclaim-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:claim-ticket-unclaim-message").success.add([
+    opendiscord.verifybars.get("opendiscord:claim-ticket-unclaim-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.claim
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already claimed
-            if (ticket.get("openticket:claimed").value){
+            if (ticket.get("opendiscord:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start claiming ticket
             if (params.data == "reason"){
                 //claim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:claim-ticket-reason").build("unclaim-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:claim-ticket-reason").build("unclaim-message",{guild,channel,user,ticket}))
             }else{
                 //claim without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run("unclaim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:claim-ticket").run("unclaim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:claim-message").build("unclaim-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build("unclaim-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:claim-ticket-unclaim-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:claim-ticket-unclaim-message").failure.add([
-        new api.ODWorker("openticket:back-to-unclaim-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-unclaim-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:unclaim-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
 }

src/actions/clearTickets.ts

@@ -1,40 +1,60 @@
 ///////////////////////////////////////
 //CLEAR TICKETS SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:clear-tickets"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:clear-tickets"))
-    openticket.actions.get("openticket:clear-tickets").workers.add([
+    opendiscord.actions.get("opendiscord:clear-tickets").workers.add([
-        new api.ODWorker("openticket:clear-tickets",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:clear-tickets",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,filter,list} = params
             
-            await openticket.events.get("onTicketsClear").emit([list,user,channel,filter])
+            await opendiscord.events.get("onTicketsClear").emit([list,user,channel,filter])
             const nameList: string[] = []
-            for (const ticket of list){
+
-                const ticketChannel = await openticket.tickets.getTicketChannel(ticket)
+            //split tickets into smaller groups of 10 (to decrease ratelimit chances for HTML Transcripts & discord API)
-                if (!ticketChannel) return
+            const subGroupList: api.ODTicket[][] = []
-                nameList.push("#"+ticketChannel.name)
+            let tempSubGroup: api.ODTicket[] = []
-                await openticket.actions.get("openticket:delete-ticket").run("clear",{guild,channel:ticketChannel,user,ticket,reason:"Cleared Ticket",sendMessage:true,withoutTranscript:false})
+            list.forEach((ticket,index) => {
+                tempSubGroup.push(ticket)
+                if (tempSubGroup.length >= 10){
+                    subGroupList.push(tempSubGroup)
+                    tempSubGroup = []
+                }
+            })
+            if (tempSubGroup.length > 0) subGroupList.push(tempSubGroup)
+
+            let groupIndex = 0
+            for (const ticketGroup of subGroupList){
+                for (const ticket of ticketGroup){
+                    const ticketChannel = await opendiscord.tickets.getTicketChannel(ticket)
+                    if (!ticketChannel) return
+                    nameList.push("#"+ticketChannel.name)
+                    await opendiscord.actions.get("opendiscord:delete-ticket").run("clear",{guild,channel:ticketChannel,user,ticket,reason:"Cleared Ticket",sendMessage:true,withoutTranscript:false})
+                    await utilities.timer(2000) //wait 2sec between each deletion
+                }
+                if (groupIndex < subGroupList.length-1) await utilities.timer(45*1000) //wait 45sec between each group deletion (10 tickets)
+                groupIndex++
             }
+            
             instance.list = nameList
-            await openticket.events.get("afterTicketsCleared").emit([list,user,channel,filter])
+            await opendiscord.events.get("afterTicketsCleared").emit([list,user,channel,filter])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,filter,list} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.deleting.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:clear-logs").build(source,{guild,channel,user,filter,list:instance.list ?? []}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:clear-logs").build(source,{guild,channel,user,filter,list:instance.list ?? []}))
             }
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,user,filter,list} = params
-            openticket.log(user.displayName+" cleared "+list.length+" tickets!","info",[
+            opendiscord.log(user.displayName+" cleared "+list.length+" tickets!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"method",value:source},

src/actions/closeTicket.ts

@@ -1,46 +1,48 @@
 ///////////////////////////////////////
 //TICKET CLOSING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:close-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:close-ticket"))
-    openticket.actions.get("openticket:close-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:close-ticket").workers.add([
-        new api.ODWorker("openticket:close-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to close ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketClose").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketClose").emit([ticket,user,channel,reason])
             
             //update ticket
-            ticket.get("openticket:closed").value = true
+            ticket.get("opendiscord:closed").value = true
-            if (source == "autoclose") ticket.get("openticket:autoclosed").value = true
+            if (source == "autoclose") ticket.get("opendiscord:autoclosed").value = true
-            ticket.get("openticket:open").value = false
+            ticket.get("opendiscord:open").value = false
-            ticket.get("openticket:closed-by").value = user.id
+            ticket.get("opendiscord:closed-by").value = user.id
-            ticket.get("openticket:closed-on").value = new Date().getTime()
+            ticket.get("opendiscord:closed-on").value = new Date().getTime()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-closed",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-closed",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-closed",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-closed",user.id,1,"increase")
 
             //update category
-            const closeCategory = ticket.option.get("openticket:channel-category-closed").value
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
-            if (closeCategory !== ""){
+                const closeCategory = ticket.option.get("opendiscord:channel-category-closed").value
-                try {
+                if (closeCategory !== ""){
-                    channel.setParent(closeCategory,{lockPermissions:false})
+                    try {
-                    ticket.get("openticket:category-mode").value = "closed"
+                        channel.setParent(closeCategory,{lockPermissions:false})
-                    ticket.get("openticket:category").value = closeCategory
+                        ticket.get("opendiscord:category-mode").value = "closed"
-                }catch(e){
+                        ticket.get("opendiscord:category").value = closeCategory
-                    openticket.log("Unable to move ticket to 'closed category'!","error",[
+                    }catch(e){
-                        {key:"channel",value:"#"+channel.name},
+                        opendiscord.log("Unable to move ticket to 'closed category'!","error",[
-                        {key:"channelid",value:channel.id,hidden:true},
+                            {key:"channel",value:"#"+channel.name},
-                        {key:"categoryid",value:closeCategory}
+                            {key:"channelid",value:channel.id,hidden:true},
-                    ])
+                            {key:"categoryid",value:closeCategory}
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    }
                 }
             }
 
@@ -51,9 +53,9 @@ export const registerActions = async () => {
                 allow:[],
                 deny:["ViewChannel","SendMessages","ReadMessageHistory"]
             }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
-            const optionAdmins = ticket.option.get("openticket:admins").value
+            const optionAdmins = ticket.option.get("opendiscord:admins").value
-            const readonlyAdmins = ticket.option.get("openticket:admins-readonly").value
+            const readonlyAdmins = ticket.option.get("opendiscord:admins-readonly").value
 
             globalAdmins.forEach((admin) => {
                 permissions.push({
@@ -82,7 +84,7 @@ export const registerActions = async () => {
                     deny:["SendMessages","AddReactions","AttachFiles","SendPolls"]
                 })
             })
-            ticket.get("openticket:participants").value.forEach((participant) => {
+            ticket.get("opendiscord:participants").value.forEach((participant) => {
                 //all participants that aren't roles/admins => readonly (OR non-viewable when enabled)
                 if (participant.type == "user"){
                     if (generalConfig.data.system.removeParticipantsOnClose) permissions.push({
@@ -102,42 +104,43 @@ export const registerActions = async () => {
             channel.permissionOverwrites.set(permissions)
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket closing!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket closing!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:close-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:close-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketClosed").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketClosed").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.closing.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.closing.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.closing.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"close",reason,additionalData:null}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" closed a ticket!","info",[
+            opendiscord.log(user.displayName+" closed a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -147,188 +150,188 @@ export const registerActions = async () => {
             ])
         })
     ])
-    openticket.actions.get("openticket:close-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:close-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }
 
 export const registerVerifyBars = async () => {
     //CLOSE TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:close-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:close-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:close-ticket-ticket-message").success.add([
+    opendiscord.verifybars.get("opendiscord:close-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.close
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already closed
-            if (ticket.get("openticket:closed").value){
+            if (ticket.get("opendiscord:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start closing ticket
             if (params.data == "reason"){
                 //close with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:close-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:close-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
             }else{
                 //close without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:close-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:close-ticket-ticket-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:close-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 
     //CLOSE TICKET REOPEN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:close-ticket-reopen-message",openticket.builders.messages.getSafe("openticket:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:close-ticket-reopen-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:close-ticket-reopen-message").success.add([
+    opendiscord.verifybars.get("opendiscord:close-ticket-reopen-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.close
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already closed
-            if (ticket.get("openticket:closed").value){
+            if (ticket.get("opendiscord:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start closing ticket
             if (params.data == "reason"){
                 //close with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:close-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:close-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
             }else{
                 //close without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:close-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:close-ticket-reopen-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:close-ticket-reopen-message").failure.add([
-        new api.ODWorker("openticket:back-to-reopen-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-reopen-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
 }

src/actions/createTicket.ts

@@ -1,26 +1,26 @@
 ///////////////////////////////////////
 //TICKET CREATION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:create-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:create-ticket"))
-    openticket.actions.get("openticket:create-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:create-ticket").workers.add([
-        new api.ODWorker("openticket:create-ticket",3,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:create-ticket",3,async (instance,params,source,cancel) => {
             const {guild,user,answers,option} = params
 
-            await openticket.events.get("onTicketCreate").emit([user])
+            await opendiscord.events.get("onTicketCreate").emit([user])
-            await openticket.events.get("onTicketChannelCreation").emit([option,user])
+            await opendiscord.events.get("onTicketChannelCreation").emit([option,user])
 
             //get channel properties
-            const channelPrefix = option.get("openticket:channel-prefix").value
+            const channelPrefix = option.get("opendiscord:channel-prefix").value
-            const channelCategory = option.get("openticket:channel-category").value
+            const channelCategory = option.get("opendiscord:channel-category").value
-            const channelBackupCategory = option.get("openticket:channel-category-backup").value
+            const channelBackupCategory = option.get("opendiscord:channel-category-backup").value
-            const channelDescription = option.get("openticket:channel-description").value
+            const channelDescription = option.get("opendiscord:channel-description").value
-            const channelSuffix = openticket.options.suffix.getSuffixFromOption(option,user)
+            const channelSuffix = opendiscord.options.suffix.getSuffixFromOption(option,user)
             const channelName = channelPrefix+channelSuffix
 
             //handle category
@@ -28,10 +28,10 @@ export const registerActions = async () => {
             let categoryMode: "backup"|"normal"|null = null
             if (channelCategory != ""){
                 //category enabled
-                const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
+                const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
                 if (!normalCategory){
                     //default category was not found
-                    openticket.log("Ticket Creation Error: Unable to find category! #1","error",[
+                    opendiscord.log("Ticket Creation Error: Unable to find category! #1","error",[
                         {key:"categoryid",value:channelCategory},
                         {key:"backup",value:"false"}
                     ])
@@ -39,10 +39,10 @@ export const registerActions = async () => {
                     //default category was found
                     if (normalCategory.children.cache.size >= 50 && channelBackupCategory != ""){
                         //use backup category
-                        const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                        const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
                         if (!backupCategory){
                             //default category was not found
-                            openticket.log("Ticket Creation Error: Unable to find category! #2","error",[
+                            opendiscord.log("Ticket Creation Error: Unable to find category! #2","error",[
                                 {key:"categoryid",value:channelBackupCategory},
                                 {key:"backup",value:"true"}
                             ])
@@ -65,9 +65,9 @@ export const registerActions = async () => {
                 allow:[],
                 deny:["ViewChannel","SendMessages","ReadMessageHistory"]
             }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
-            const optionAdmins = option.get("openticket:admins").value
+            const optionAdmins = option.get("opendiscord:admins").value
-            const readonlyAdmins = option.get("openticket:admins-readonly").value
+            const readonlyAdmins = option.get("opendiscord:admins-readonly").value
 
             globalAdmins.forEach((admin) => {
                 permissions.push({
@@ -114,7 +114,7 @@ export const registerActions = async () => {
                 permissionOverwrites:permissions
             })
 
-            await openticket.events.get("afterTicketChannelCreated").emit([option,channel,user])
+            await opendiscord.events.get("afterTicketChannelCreated").emit([option,channel,user])
 
             //create participants
             const participants: {type:"role"|"user",id:string}[] = []
@@ -127,96 +127,96 @@ export const registerActions = async () => {
 
             //create ticket
             const ticket = new api.ODTicket(channel.id,option,[
-                new api.ODTicketData("openticket:busy",false),
+                new api.ODTicketData("opendiscord:busy",false),
-                new api.ODTicketData("openticket:ticket-message",null),
+                new api.ODTicketData("opendiscord:ticket-message",null),
-                new api.ODTicketData("openticket:participants",participants),
+                new api.ODTicketData("opendiscord:participants",participants),
-                new api.ODTicketData("openticket:channel-suffix",channelSuffix),
+                new api.ODTicketData("opendiscord:channel-suffix",channelSuffix),
                 
-                new api.ODTicketData("openticket:open",true),
+                new api.ODTicketData("opendiscord:open",true),
-                new api.ODTicketData("openticket:opened-by",user.id),
+                new api.ODTicketData("opendiscord:opened-by",user.id),
-                new api.ODTicketData("openticket:opened-on",new Date().getTime()),
+                new api.ODTicketData("opendiscord:opened-on",new Date().getTime()),
-                new api.ODTicketData("openticket:closed",false),
+                new api.ODTicketData("opendiscord:closed",false),
-                new api.ODTicketData("openticket:closed-by",null),
+                new api.ODTicketData("opendiscord:closed-by",null),
-                new api.ODTicketData("openticket:closed-on",null),
+                new api.ODTicketData("opendiscord:closed-on",null),
-                new api.ODTicketData("openticket:claimed",false),
+                new api.ODTicketData("opendiscord:claimed",false),
-                new api.ODTicketData("openticket:claimed-by",null),
+                new api.ODTicketData("opendiscord:claimed-by",null),
-                new api.ODTicketData("openticket:claimed-on",null),
+                new api.ODTicketData("opendiscord:claimed-on",null),
-                new api.ODTicketData("openticket:pinned",false),
+                new api.ODTicketData("opendiscord:pinned",false),
-                new api.ODTicketData("openticket:pinned-by",null),
+                new api.ODTicketData("opendiscord:pinned-by",null),
-                new api.ODTicketData("openticket:pinned-on",null),
+                new api.ODTicketData("opendiscord:pinned-on",null),
-                new api.ODTicketData("openticket:for-deletion",false),
+                new api.ODTicketData("opendiscord:for-deletion",false),
 
-                new api.ODTicketData("openticket:category",category),
+                new api.ODTicketData("opendiscord:category",category),
-                new api.ODTicketData("openticket:category-mode",categoryMode),
+                new api.ODTicketData("opendiscord:category-mode",categoryMode),
 
-                new api.ODTicketData("openticket:autoclose-enabled",option.get("openticket:autoclose-enable-hours").value),
+                new api.ODTicketData("opendiscord:autoclose-enabled",option.get("opendiscord:autoclose-enable-hours").value),
-                new api.ODTicketData("openticket:autoclose-hours",(option.get("openticket:autoclose-enable-hours").value ? option.get("openticket:autoclose-hours").value : 0)),
+                new api.ODTicketData("opendiscord:autoclose-hours",(option.get("opendiscord:autoclose-enable-hours").value ? option.get("opendiscord:autoclose-hours").value : 0)),
-                new api.ODTicketData("openticket:autoclosed",false),
+                new api.ODTicketData("opendiscord:autoclosed",false),
-                new api.ODTicketData("openticket:autodelete-enabled",option.get("openticket:autodelete-enable-days").value),
+                new api.ODTicketData("opendiscord:autodelete-enabled",option.get("opendiscord:autodelete-enable-days").value),
-                new api.ODTicketData("openticket:autodelete-days",(option.get("openticket:autodelete-enable-days").value ? option.get("openticket:autodelete-days").value : 0)),
+                new api.ODTicketData("opendiscord:autodelete-days",(option.get("opendiscord:autodelete-enable-days").value ? option.get("opendiscord:autodelete-days").value : 0)),
 
-                new api.ODTicketData("openticket:answers",answers)
+                new api.ODTicketData("opendiscord:answers",answers)
             ])
 
             //manage stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-created",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-created",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-created",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-created",user.id,1,"increase")
 
             //manage bot permissions
-            await openticket.events.get("onTicketPermissionsCreated").emit([option,openticket.permissions,channel,user])
+            await opendiscord.events.get("onTicketPermissionsCreated").emit([option,opendiscord.permissions,channel,user])
             await (await import("../data/framework/permissionLoader.js")).addTicketPermissions(ticket)
-            await openticket.events.get("afterTicketPermissionsCreated").emit([option,openticket.permissions,channel,user])
+            await opendiscord.events.get("afterTicketPermissionsCreated").emit([option,opendiscord.permissions,channel,user])
 
             //export channel & ticket
             instance.channel = channel
             instance.ticket = ticket
-            openticket.tickets.add(ticket)
+            opendiscord.tickets.add(ticket)
         }),
-        new api.ODWorker("openticket:send-ticket-message",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:send-ticket-message",2,async (instance,params,source,cancel) => {
             const {guild,user,answers,option} = params
             const {ticket,channel} = instance
 
-            if (!ticket || !channel) return openticket.log("Ticket Creation Error: Unable to send ticket message. Previous worker failed!","error")
+            if (!ticket || !channel) return opendiscord.log("Ticket Creation Error: Unable to send ticket message. Previous worker failed!","error")
             
-            await openticket.events.get("onTicketMainMessageCreated").emit([ticket,channel,user])
+            await opendiscord.events.get("onTicketMainMessageCreated").emit([ticket,channel,user])
             //check if ticket message is enabled
-            if (!option.get("openticket:ticket-message-enabled").value) return
+            if (!option.get("opendiscord:ticket-message-enabled").value) return
             try {
-                const msg = await channel.send((await openticket.builders.messages.getSafe("openticket:ticket-message").build(source,{guild,channel,user,ticket})).message)
+                const msg = await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build(source,{guild,channel,user,ticket})).message)
                 
-                ticket.get("openticket:ticket-message").value = msg.id
+                ticket.get("opendiscord:ticket-message").value = msg.id
                 
                 //manage stats
-                await openticket.stats.get("openticket:ticket").setStat("openticket:messages-sent",ticket.id.value,1,"increase")
+                await opendiscord.stats.get("opendiscord:ticket").setStat("opendiscord:messages-sent",ticket.id.value,1,"increase")
                 
-                await openticket.events.get("afterTicketMainMessageCreated").emit([ticket,msg,channel,user])
+                await opendiscord.events.get("afterTicketMainMessageCreated").emit([ticket,msg,channel,user])
         }catch(err){
                 process.emit("uncaughtException",err)
                 //something went wrong while sending the ticket message
-                channel.send((await openticket.builders.messages.getSafe("openticket:error").build("other",{guild,channel,user,error:"Ticket Message: Creation Error!\n=> Ticket Is Still Created Succesfully",layout:"advanced"})).message)
+                channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error").build("other",{guild,channel,user,error:"Ticket Message: Creation Error!\n=> Ticket Is Still Created Succesfully",layout:"advanced"})).message)
             }
-            await openticket.events.get("afterTicketCreated").emit([ticket,user,channel])
+            await opendiscord.events.get("afterTicketCreated").emit([ticket,user,channel])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,user,answers,option} = params
             const {ticket,channel} = instance
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.creation.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-created-logs").build(source,{guild,channel,user,ticket}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-created-logs").build(source,{guild,channel,user,ticket}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.creation.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-created-dm").build(source,{guild,channel,user,ticket}))
+            if (generalConfig.data.system.messages.creation.dm) await opendiscord.client.sendUserDm(user,await opendiscord.builders.messages.getSafe("opendiscord:ticket-created-dm").build(source,{guild,channel,user,ticket}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,user,answers,option} = params
             const {ticket,channel} = instance
 
-            if (!ticket || !channel) return openticket.log("Ticket Creation Error: Unable to create logs. Previous worker failed!","error")
+            if (!ticket || !channel) return opendiscord.log("Ticket Creation Error: Unable to create logs. Previous worker failed!","error")
 
-            openticket.log(user.displayName+" created a ticket!","info",[
+            opendiscord.log(user.displayName+" created a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},

src/actions/createTicketPermissions.ts

@@ -1,17 +1,17 @@
 ///////////////////////////////////////
 //TICKET CREATION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:create-ticket-permissions"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:create-ticket-permissions"))
-    openticket.actions.get("openticket:create-ticket-permissions").workers.add([
+    opendiscord.actions.get("opendiscord:create-ticket-permissions").workers.add([
-        new api.ODWorker("openticket:check-blacklist",4,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:check-blacklist",4,(instance,params,source,cancel) => {
-            if (!params.option.get("openticket:allow-blacklisted-users").value && openticket.blacklist.exists(params.user.id)){
+            if (!params.option.get("opendiscord:allow-blacklisted-users").value && opendiscord.blacklist.exists(params.user.id)){
                 instance.valid = false
                 instance.reason = "blacklist"
-                openticket.log(params.user.displayName+" tried to create a ticket but is blacklisted!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket but is blacklisted!","info",[
                     {key:"user",value:params.user.username},
                     {key:"userid",value:params.user.id,hidden:true},
                     {key:"option",value:params.option.id.value}
@@ -19,15 +19,15 @@ export const registerActions = async () => {
                 return cancel()
             }
         }),
-        new api.ODWorker("openticket:check-cooldown",3,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:check-cooldown",3,(instance,params,source,cancel) => {
-            const cooldown = openticket.cooldowns.get("openticket:option-cooldown_"+params.option.id.value)
+            const cooldown = opendiscord.cooldowns.get("opendiscord:option-cooldown_"+params.option.id.value)
             if (cooldown && cooldown instanceof api.ODTimeoutCooldown && cooldown.use(params.user.id)){
                 instance.valid = false
                 instance.reason = "cooldown"
                 const remaining = cooldown.remaining(params.user.id) ?? 0
                 instance.cooldownUntil = new Date(new Date().getTime() + remaining)
 
-                openticket.log(params.user.displayName+" tried to create a ticket but is on cooldown!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket but is on cooldown!","info",[
                     {key:"user",value:params.user.username},
                     {key:"userid",value:params.user.id,hidden:true},
                     {key:"option",value:params.option.id.value},
@@ -36,19 +36,19 @@ export const registerActions = async () => {
                 return cancel()
             }
         }),
-        new api.ODWorker("openticket:check-global-limits",2,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:check-global-limits",2,(instance,params,source,cancel) => {
-            const generalConfig = openticket.configs.get("openticket:general")
+            const generalConfig = opendiscord.configs.get("opendiscord:general")
             if (!generalConfig.data.system.limits.enabled) return
 
-            const allTickets = openticket.tickets.getAll()
+            const allTickets = opendiscord.tickets.getAll()
             const globalTicketCount = allTickets.length
-            const userTickets = openticket.tickets.getFiltered((ticket) => ticket.exists("openticket:opened-by") && (ticket.get("openticket:opened-by").value == params.user.id))
+            const userTickets = opendiscord.tickets.getFiltered((ticket) => ticket.exists("opendiscord:opened-by") && (ticket.get("opendiscord:opened-by").value == params.user.id))
             const userTicketCount = userTickets.length
 
             if (globalTicketCount >= generalConfig.data.system.limits.globalMaximum){
                 instance.valid = false
                 instance.reason = "global-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket but reached the limit!","info",[
                     {key:"user",value:params.user.username},
                     {key:"userid",value:params.user.id,hidden:true},
                     {key:"option",value:params.option.id.value},
@@ -58,7 +58,7 @@ export const registerActions = async () => {
             }else if (userTicketCount >= generalConfig.data.system.limits.userMaximum){
                 instance.valid = false
                 instance.reason = "global-user-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
                     {key:"user",value:params.user.username},
                     {key:"userid",value:params.user.id,hidden:true},
                     {key:"option",value:params.option.id.value},
@@ -67,28 +67,28 @@ export const registerActions = async () => {
                 return cancel()
             }
         }),
-        new api.ODWorker("openticket:check-option-limits",1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:check-option-limits",1,(instance,params,source,cancel) => {
-            if (!params.option.exists("openticket:limits-enabled") || !params.option.get("openticket:limits-enabled").value) return
+            if (!params.option.exists("opendiscord:limits-enabled") || !params.option.get("opendiscord:limits-enabled").value) return
 
-            const allTickets = openticket.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value)
+            const allTickets = opendiscord.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value)
             const globalTicketCount = allTickets.length
-            const userTickets = openticket.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value && ticket.exists("openticket:opened-by") && (ticket.get("openticket:opened-by").value == params.user.id))
+            const userTickets = opendiscord.tickets.getFiltered((ticket) => ticket.option.id.value == params.option.id.value && ticket.exists("opendiscord:opened-by") && (ticket.get("opendiscord:opened-by").value == params.user.id))
             const userTicketCount = userTickets.length
 
-            if (globalTicketCount >= params.option.get("openticket:limits-maximum-global").value){
+            if (globalTicketCount >= params.option.get("opendiscord:limits-maximum-global").value){
                 instance.valid = false
                 instance.reason = "option-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
                     {key:"user",value:params.user.username},
                     {key:"userid",value:params.user.id,hidden:true},
                     {key:"option",value:params.option.id.value},
                     {key:"limit",value:"option"}
                 ])
                 return cancel()
-            }else if (userTicketCount >= params.option.get("openticket:limits-maximum-user").value){
+            }else if (userTicketCount >= params.option.get("opendiscord:limits-maximum-user").value){
                 instance.valid = false
                 instance.reason = "option-user-limit"
-                openticket.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
+                opendiscord.log(params.user.displayName+" tried to create a ticket, but reached the limit!","info",[
                     {key:"user",value:params.user.username},
                     {key:"userid",value:params.user.id,hidden:true},
                     {key:"option",value:params.option.id.value},
@@ -97,7 +97,7 @@ export const registerActions = async () => {
                 return cancel()
             }
         }),
-        new api.ODWorker("openticket:valid",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:valid",0,(instance,params,source,cancel) => {
             instance.valid = true
             instance.reason = null
             cancel()

src/actions/createTranscript.ts

@@ -1,23 +1,23 @@
 ///////////////////////////////////////
 //TRANSCRIPT CREATION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const transcriptConfig = openticket.configs.get("openticket:transcripts")
+const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:create-transcript"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:create-transcript"))
-    openticket.actions.get("openticket:create-transcript").workers.add([
+    opendiscord.actions.get("opendiscord:create-transcript").workers.add([
-        new api.ODWorker("openticket:select-compiler",4,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:select-compiler",4,async (instance,params,source,cancel) => {
             const {channel,user,ticket} = params
             if (channel.type != discord.ChannelType.GuildText) return cancel()
             if (!transcriptConfig.data.general.enabled) return cancel()
             
-            await openticket.events.get("onTranscriptCreate").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("onTranscriptCreate").emit([opendiscord.transcripts,ticket,channel,user])
             
             instance.errorReason = null
-            const participants = await openticket.tickets.getAllTicketParticipants(params.ticket)
+            const participants = await opendiscord.tickets.getAllTicketParticipants(params.ticket)
             if (!participants){
                 instance.pendingMessage = null
                 instance.errorReason = "Unable to fetch ticket channel participants!"
@@ -26,22 +26,22 @@ export const registerActions = async () => {
             instance.participants = participants
 
             //select transcript compiler
-            if (transcriptConfig.data.general.mode == "text") instance.compiler = openticket.transcripts.get("openticket:text-compiler")
+            if (transcriptConfig.data.general.mode == "text") instance.compiler = opendiscord.transcripts.get("opendiscord:text-compiler")
-            else if (transcriptConfig.data.general.mode == "html") instance.compiler = openticket.transcripts.get("openticket:html-compiler")
+            else if (transcriptConfig.data.general.mode == "html") instance.compiler = opendiscord.transcripts.get("opendiscord:html-compiler")
         }),
-        new api.ODWorker("openticket:init-transcript",3,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:init-transcript",3,async (instance,params,source,cancel) => {
             const {channel,user,ticket} = params
             if (channel.type != discord.ChannelType.GuildText) return cancel()
             if (!transcriptConfig.data.general.enabled) return cancel()
             
             //run transcript compiler init()
-            await openticket.events.get("onTranscriptInit").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("onTranscriptInit").emit([opendiscord.transcripts,ticket,channel,user])
             if (instance.compiler.init){
                 try{
                     const result = await instance.compiler.init(ticket,channel,user)
                     if (result.success && result.pendingMessage && transcriptConfig.data.general.enableChannel){
                         //send init message to channel
-                        const post = openticket.posts.get("openticket:transcripts")
+                        const post = opendiscord.posts.get("opendiscord:transcripts")
                         if (post){
                             instance.pendingMessage = await post.send(result.pendingMessage)
                         }
@@ -57,9 +57,9 @@ export const registerActions = async () => {
                     throw new api.ODSystemError("ODAction(ot:create-transcript) => Failed transcript compiler init()! (see error above)")
                 }
             }
-            await openticket.events.get("afterTranscriptInitiated").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("afterTranscriptInitiated").emit([opendiscord.transcripts,ticket,channel,user])
         }),
-        new api.ODWorker("openticket:compile-transcript",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:compile-transcript",2,async (instance,params,source,cancel) => {
             const {channel,user,ticket} = params
             if (channel.type != discord.ChannelType.GuildText) return cancel()
             if (!instance.compiler){
@@ -69,7 +69,7 @@ export const registerActions = async () => {
             }
 
             //run transcript compiler compile()
-            await openticket.events.get("onTranscriptCompile").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("onTranscriptCompile").emit([opendiscord.transcripts,ticket,channel,user])
             if (instance.compiler.compile){
                 try{
                     const result = await instance.compiler.compile(ticket,channel,user)
@@ -87,9 +87,9 @@ export const registerActions = async () => {
                     throw new api.ODSystemError("ODAction(ot:create-transcript) => Failed transcript compiler compile()! (see error above)")
                 }
             }
-            await openticket.events.get("afterTranscriptCompiled").emit([openticket.transcripts,ticket,channel,user])
+            await opendiscord.events.get("afterTranscriptCompiled").emit([opendiscord.transcripts,ticket,channel,user])
         }),
-        new api.ODWorker("openticket:ready-transcript",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:ready-transcript",1,async (instance,params,source,cancel) => {
             if (!instance.result){
                 instance.success = false
                 cancel()
@@ -98,7 +98,7 @@ export const registerActions = async () => {
 
             //run transcript compiler ready()
             utilities.runAsync(async () => {
-                await openticket.events.get("onTranscriptReady").emit([openticket.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
+                await opendiscord.events.get("onTranscriptReady").emit([opendiscord.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
                 if (instance.compiler.ready){
                     try{
                         const {channelMessage,creatorDmMessage,participantDmMessage,activeAdminDmMessage,everyAdminDmMessage} = await instance.compiler.ready(instance.result)
@@ -110,7 +110,7 @@ export const registerActions = async () => {
                                 instance.pendingMessage.message.edit(channelMessage.message)
                             }else{
                                 //send ready message to channel
-                                const post = openticket.posts.get("openticket:transcripts")
+                                const post = opendiscord.posts.get("opendiscord:transcripts")
                                 if (post) await post.send(channelMessage)
                             }
                         }
@@ -120,16 +120,16 @@ export const registerActions = async () => {
                             for (const p of instance.participants){
                                 if (p.role == "creator" && transcriptConfig.data.general.enableCreatorDM && creatorDmMessage){
                                     //send creator dm message
-                                    await openticket.client.sendUserDm(p.user,creatorDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,creatorDmMessage)
                                 }else if (p.role == "participant" && transcriptConfig.data.general.enableParticipantDM && participantDmMessage){
                                     //send participant dm message
-                                    await openticket.client.sendUserDm(p.user,participantDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,participantDmMessage)
                                 }else if (p.role == "admin" && transcriptConfig.data.general.enableActiveAdminDM && instance.result.success && instance.result.messages && instance.result.messages.some((msg) => msg.author.id == p.user.id) && activeAdminDmMessage){
                                     //send active admin dm message
-                                    await openticket.client.sendUserDm(p.user,activeAdminDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,activeAdminDmMessage)
                                 }else if (p.role == "admin" && transcriptConfig.data.general.enableEveryAdminDM && everyAdminDmMessage){
                                     //send every admin dm message
-                                    await openticket.client.sendUserDm(p.user,everyAdminDmMessage)
+                                    await opendiscord.client.sendUserDm(p.user,everyAdminDmMessage)
                                 }
                             }
                         }
@@ -141,17 +141,17 @@ export const registerActions = async () => {
                         throw new api.ODSystemError("ODAction(ot:create-transcript) => Failed transcript compiler ready()! (see error above)")
                     }
                 }
-                await openticket.events.get("afterTranscriptReady").emit([openticket.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
+                await opendiscord.events.get("afterTranscriptReady").emit([opendiscord.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
             })
 
             //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:transcripts-created",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:transcripts-created",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:transcripts-created",params.user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:transcripts-created",params.user.id,1,"increase")
-            await openticket.events.get("afterTranscriptCreated").emit([openticket.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
+            await opendiscord.events.get("afterTranscriptCreated").emit([opendiscord.transcripts,instance.result.ticket,instance.result.channel,instance.result.user])
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {user,channel,ticket} = params
-            openticket.log(user.displayName+" created a transcript!","info",[
+            opendiscord.log(user.displayName+" created a transcript!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},

src/actions/deleteTicket.ts

@@ -1,53 +1,55 @@
 ///////////////////////////////////////
 //TICKET DELETION SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:delete-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:delete-ticket"))
-    openticket.actions.get("openticket:delete-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:delete-ticket").workers.add([
-        new api.ODWorker("openticket:delete-ticket",3,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",3,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to delete ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketDelete").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketDelete").emit([ticket,user,channel,reason])
 
             //update ticket
-            ticket.get("openticket:for-deletion").value = true
+            ticket.get("opendiscord:for-deletion").value = true
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket deletion!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket deletion!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:delete-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build(source,{guild,channel,user,ticket,reason})).message)
         
             //create transcript
             if (!params.withoutTranscript){
-                const transcriptRes = await openticket.actions.get("openticket:create-transcript").run(source,{guild,channel,user,ticket})
+                const transcriptRes = await opendiscord.actions.get("opendiscord:create-transcript").run(source,{guild,channel,user,ticket})
+                //transcript failure
                 if (typeof transcriptRes.success == "boolean" && !transcriptRes.success && transcriptRes.compiler){
                     const {compiler} = transcriptRes
-                    await channel.send((await openticket.builders.messages.getSafe("openticket:transcript-error").build(source,{guild,channel,user,ticket,compiler,reason:transcriptRes.errorReason ?? null})).message)
+                    await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:transcript-error").build(source,{guild,channel,user,ticket,compiler,reason:transcriptRes.errorReason ?? null})).message)
+                        .catch((reason) => opendiscord.log("Unable to send transcript failure to ticket channel!","error",[{key:"id",value:channel.id}]))
                 
                     //undo deletion
-                    ticket.get("openticket:for-deletion").value = false
+                    ticket.get("opendiscord:for-deletion").value = false
-                    ticket.get("openticket:busy").value = false
+                    ticket.get("opendiscord:busy").value = false
-                    openticket.log("Canceled ticket deletion because of transcript system malfunction!","warning",[
+                    opendiscord.log("Canceled ticket deletion because of transcript system malfunction!","warning",[
                         {key:"compiler",value:compiler.id.value},
                         {key:"reason",value:transcriptRes.errorReason ?? "/"},
                     ])
@@ -56,44 +58,45 @@ export const registerActions = async () => {
             }
 
             //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-deleted",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-deleted",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-deleted",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-deleted",user.id,1,"increase")
 
             //delete ticket from manager
-            openticket.tickets.remove(ticket.id)
+            opendiscord.tickets.remove(ticket.id)
 
             //delete permissions from manager
             await (await import("../data/framework/permissionLoader.js")).removeTicketPermissions(ticket)
         }),
-        new api.ODWorker("openticket:discord-logs",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",2,async (instance,params,source,cancel) => {
             //logs before channel deletion => channel might still be used in log embeds
             const {guild,channel,user,ticket,reason} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.deleting.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.deleting.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.deleting.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"delete",reason,additionalData:null}))
         }),
-        new api.ODWorker("openticket:delete-channel",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-channel",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             //delete channel & events
-            await openticket.events.get("onTicketChannelDeletion").emit([ticket,channel,user])
+            await opendiscord.events.get("onTicketChannelDeletion").emit([ticket,channel,user])
-            await channel.delete("Ticket Deleted")
+            await channel.delete("Ticket Deleted").catch((reason) => opendiscord.log("Unable to delete ticket channel!","error",[{key:"id",value:channel.id}]))
-            await openticket.events.get("afterTicketChannelDeleted").emit([ticket,user])
+            await opendiscord.events.get("afterTicketChannelDeleted").emit([ticket,user])
 
             //delete permissions from manager
             await (await import("../data/framework/permissionLoader.js")).removeTicketPermissions(ticket)
 
-            await openticket.events.get("afterTicketDeleted").emit([ticket,user,reason])
+            await opendiscord.events.get("afterTicketDeleted").emit([ticket,user,reason])
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" deleted a ticket!","info",[
+            opendiscord.log(user.displayName+" deleted a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -104,360 +107,360 @@ export const registerActions = async () => {
             ])
         })
     ])
-    openticket.actions.get("openticket:delete-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:delete-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
-        params.ticket.get("openticket:for-deletion").value = false
+        params.ticket.get("opendiscord:for-deletion").value = false
     })
 }
 
 export const registerVerifyBars = async () => {
     //DELETE TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-ticket-message").success.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.delete
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start deleting ticket
             if (params.data == "reason"){
                 //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
             }else{
                 //delete without reason
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true,withoutTranscript:(params.data == "no-transcript")})
                 //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
+                ticket.get("opendiscord:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:delete-ticket-ticket-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 
     //DELETE TICKET CLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-close-message",openticket.builders.messages.getSafe("openticket:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-close-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-close-message").success.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-close-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.delete
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start deleting ticket
             if (params.data == "reason"){
                 //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("close-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("close-message",{guild,channel,user,ticket}))
             }else{
                 //delete without reason
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
                 //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
+                ticket.get("opendiscord:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("close-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("close-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:delete-ticket-close-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-close-message").failure.add([
-        new api.ODWorker("openticket:back-to-close-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-close-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
 
     //DELETE TICKET REOPEN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-reopen-message",openticket.builders.messages.getSafe("openticket:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-reopen-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-reopen-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-reopen-message").success.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-reopen-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.delete
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start deleting ticket
             if (params.data == "reason"){
                 //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("reopen-message",{guild,channel,user,ticket}))
             }else{
                 //delete without reason
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("reopen-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
                 //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
+                ticket.get("opendiscord:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("reopen-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:delete-ticket-reopen-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-reopen-message").failure.add([
-        new api.ODWorker("openticket:back-to-reopen-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-reopen-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
 
     //DELETE TICKET AUTOCLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:delete-ticket-autoclose-message",openticket.builders.messages.getSafe("openticket:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:delete-ticket-autoclose-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:delete-ticket-autoclose-message").success.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-autoclose-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.delete
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start deleting ticket
             if (params.data == "reason"){
                 //delete with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:delete-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:delete-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
             }else{
                 //delete without reason
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
+                opendiscord.actions.get("opendiscord:delete-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false,withoutTranscript:(params.data == "no-transcript")})
                 //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
+                ticket.get("opendiscord:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:delete-ticket-autoclose-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:delete-ticket-autoclose-message").failure.add([
-        new api.ODWorker("openticket:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:autoclose-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 }

src/actions/handleTranscriptErrors.ts

@@ -1,80 +1,79 @@
 ///////////////////////////////////////
 //TRANSCRIPT ERROR SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerButtonResponders = async () => {
     //TRANSCRIPT ERROR RETRY
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:transcript-error-retry",/^od:transcript-error-retry_([^_]+)/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:transcript-error-retry",/^od:transcript-error-retry_([^_]+)/))
-    openticket.responders.buttons.get("openticket:transcript-error-retry").workers.add([
+    opendiscord.responders.buttons.get("opendiscord:transcript-error-retry").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.delete
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
-            const originalSource = instance.interaction.customId.split("_")[1]
+            const originalSource = instance.interaction.customId.split("_")[1] as api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"]
-            if (originalSource != "slash" && originalSource != "text" && originalSource != "ticket-message" && originalSource != "reopen-message" && originalSource != "close-message" && originalSource != "other") return
             
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start deleting ticket (without reason)
             await instance.defer("update",false)
             //don't await DELETE action => else it will update the message after the channel has been deleted
-            openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Retried)",sendMessage:false,withoutTranscript:false})
+            opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Retried)",sendMessage:false,withoutTranscript:false})
             //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-            ticket.get("openticket:for-deletion").value = true
+            ticket.get("opendiscord:for-deletion").value = true
-            await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Retried)"}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Retried)"}))
         
         }),
-        new api.ODWorker("openticket:logs",-1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,async (instance,params,source,cancel) => {
             const {user,channel} = instance
             if (channel.isDMBased()) return
-            openticket.log(user.displayName+" retried deleting a ticket with transcript!","info",[
+            opendiscord.log(user.displayName+" retried deleting a ticket with transcript!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -85,74 +84,73 @@ export const registerButtonResponders = async () => {
     ])
 
     //TRANSCRIPT ERROR CONTINUE
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:transcript-error-continue",/^od:transcript-error-continue_([^_]+)/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:transcript-error-continue",/^od:transcript-error-continue_([^_]+)/))
-    openticket.responders.buttons.get("openticket:transcript-error-continue").workers.add([
+    opendiscord.responders.buttons.get("opendiscord:transcript-error-continue").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.delete
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
-            const originalSource = instance.interaction.customId.split("_")[1]
+            const originalSource = instance.interaction.customId.split("_")[1] as api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"]
-            if (originalSource != "slash" && originalSource != "text" && originalSource != "ticket-message" && originalSource != "reopen-message" && originalSource != "close-message" && originalSource != "other") return
             
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start deleting ticket (without reason)
             await instance.defer("update",false)
             //don't await DELETE action => else it will update the message after the channel has been deleted
-            openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Continued)",sendMessage:false,withoutTranscript:true})
+            opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason:"Transcript Error (Continued)",sendMessage:false,withoutTranscript:true})
             //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-            ticket.get("openticket:for-deletion").value = true
+            ticket.get("opendiscord:for-deletion").value = true
-            await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Continued)"}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason:"Transcript Error (Continued)"}))
         
         }),
-        new api.ODWorker("openticket:logs",-1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,async (instance,params,source,cancel) => {
             const {user,channel} = instance
             if (channel.isDMBased()) return
-            openticket.log(user.displayName+" continued deleting a ticket without transcript!","info",[
+            opendiscord.log(user.displayName+" continued deleting a ticket without transcript!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},

src/actions/handleVerifyBar.ts

@@ -1,30 +1,30 @@
 ///////////////////////////////////////
 //VERIFYBAR SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 
 export const registerButtonResponders = async () => {
     //VERIFYBAR SUCCESS
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:verifybar-success",/^od:verifybar-success_([^_]+)/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:verifybar-success",/^od:verifybar-success_([^_]+)/))
-    openticket.responders.buttons.get("openticket:verifybar-success").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:verifybar-success").workers.add(
-        new api.ODWorker("openticket:handle-verifybar",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:handle-verifybar",0,async (instance,params,source,cancel) => {
             const id = instance.interaction.customId.split("_")[1]
             const customData = instance.interaction.customId.split("_")[2] as string|undefined
             
-            const verifybar = openticket.verifybars.get(id)
+            const verifybar = opendiscord.verifybars.get(id)
             if (!verifybar) return
             if (verifybar.success) await verifybar.success.executeWorkers(instance,"verifybar",{data:customData ?? null,verifybarMessage:instance.message})
         })
     )
 
     //VERIFYBAR FAILURE
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:verifybar-failure",/^od:verifybar-failure_([^_]+)/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:verifybar-failure",/^od:verifybar-failure_([^_]+)/))
-    openticket.responders.buttons.get("openticket:verifybar-failure").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:verifybar-failure").workers.add(
-        new api.ODWorker("openticket:handle-verifybar",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:handle-verifybar",0,async (instance,params,source,cancel) => {
             const id = instance.interaction.customId.split("_")[1]
             const customData = instance.interaction.customId.split("_")[2] as string|undefined
             
-            const verifybar = openticket.verifybars.get(id)
+            const verifybar = opendiscord.verifybars.get(id)
             if (!verifybar) return
             if (verifybar.failure) await verifybar.failure.executeWorkers(instance,"verifybar",{data:customData ?? null,verifybarMessage:instance.message})
         })

src/actions/moveTicket.ts

@@ -1,34 +1,34 @@
 ///////////////////////////////////////
 //TICKET MOVING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:move-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:move-ticket"))
-    openticket.actions.get("openticket:move-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:move-ticket").workers.add([
-        new api.ODWorker("openticket:move-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:move-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to move ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketMove").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketMove").emit([ticket,user,channel,reason])
             ticket.option = data
 
             //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-moved",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-moved",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-moved",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-moved",user.id,1,"increase")
 
             //get new channel properties
-            const channelPrefix = ticket.option.get("openticket:channel-prefix").value
+            const channelPrefix = ticket.option.get("opendiscord:channel-prefix").value
-            const channelSuffix = ticket.get("openticket:channel-suffix").value
+            const channelSuffix = ticket.get("opendiscord:channel-suffix").value
-            const channelCategory = ticket.option.get("openticket:channel-category").value
+            const channelCategory = ticket.option.get("opendiscord:channel-category").value
-            const channelBackupCategory = ticket.option.get("openticket:channel-category-backup").value
+            const channelBackupCategory = ticket.option.get("opendiscord:channel-category-backup").value
-            const rawClaimCategory = ticket.option.get("openticket:channel-categories-claimed").value.find((c) => c.user == user.id)
+            const rawClaimCategory = ticket.option.get("opendiscord:channel-categories-claimed").value.find((c) => c.user == user.id)
             const claimCategory = (rawClaimCategory) ? rawClaimCategory.category : null
-            const closeCategory = ticket.option.get("openticket:channel-category-closed").value
+            const closeCategory = ticket.option.get("opendiscord:channel-category-closed").value
-            const channelDescription = ticket.option.get("openticket:channel-description").value
+            const channelDescription = ticket.option.get("opendiscord:channel-description").value
             const channelName = channelPrefix+channelSuffix
 
             //handle category
@@ -38,16 +38,16 @@ export const registerActions = async () => {
                 //use claim category
                 category = claimCategory
                 categoryMode = "claimed"
-            }else if (closeCategory != "" && ticket.get("openticket:closed").value){
+            }else if (closeCategory != "" && ticket.get("opendiscord:closed").value){
                 //use close category
                 category = closeCategory
                 categoryMode = "closed"
             }else if (channelCategory != ""){
                 //category enabled
-                const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
+                const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
                 if (!normalCategory){
                     //default category was not found
-                    openticket.log("Ticket Move Error: Unable to find category! #1","error",[
+                    opendiscord.log("Ticket Move Error: Unable to find category! #1","error",[
                         {key:"categoryid",value:channelCategory},
                         {key:"backup",value:"false"}
                     ])
@@ -55,10 +55,10 @@ export const registerActions = async () => {
                     //default category was found
                     if (normalCategory.children.cache.size >= 50 && channelBackupCategory != ""){
                         //use backup category
-                        const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                        const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
                         if (!backupCategory){
                             //default category was not found
-                            openticket.log("Ticket Move Error: Unable to find category! #2","error",[
+                            opendiscord.log("Ticket Move Error: Unable to find category! #2","error",[
                                 {key:"categoryid",value:channelBackupCategory},
                                 {key:"backup",value:"true"}
                             ])
@@ -77,17 +77,17 @@ export const registerActions = async () => {
             try {
                 //only move category when not the same.
                 if (channel.parentId != category) await utilities.timedAwait(channel.setParent(category,{lockPermissions:false}),2500,(err) => {
-                    openticket.log("Failed to change channel category on ticket move","error")
+                    opendiscord.log("Failed to change channel category on ticket move","error")
                 })
-                ticket.get("openticket:category-mode").value = categoryMode
+                ticket.get("opendiscord:category-mode").value = categoryMode
-                ticket.get("openticket:category").value = category
+                ticket.get("opendiscord:category").value = category
             }catch(e){
-                openticket.log("Unable to move ticket to 'moved category'!","error",[
+                opendiscord.log("Unable to move ticket to 'moved category'!","error",[
                     {key:"channel",value:"#"+channel.name},
                     {key:"channelid",value:channel.id,hidden:true},
                     {key:"categoryid",value:category ?? "/"}
                 ])
-                openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
             }
 
             //handle permissions
@@ -97,9 +97,9 @@ export const registerActions = async () => {
                 allow:[],
                 deny:["ViewChannel","SendMessages","ReadMessageHistory"]
             }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
-            const optionAdmins = ticket.option.get("openticket:admins").value
+            const optionAdmins = ticket.option.get("opendiscord:admins").value
-            const readonlyAdmins = ticket.option.get("openticket:admins-readonly").value
+            const readonlyAdmins = ticket.option.get("opendiscord:admins-readonly").value
 
             globalAdmins.forEach((admin) => {
                 permissions.push({
@@ -129,7 +129,7 @@ export const registerActions = async () => {
                 })
             })
             //transfer all old user-participants over to the new ticket (creator & participants)
-            ticket.get("openticket:participants").value.forEach((p) => {
+            ticket.get("opendiscord:participants").value.forEach((p) => {
                 if (p.type == "user") permissions.push({
                     type:discord.OverwriteType.Member,
                     id:p.id,
@@ -140,7 +140,7 @@ export const registerActions = async () => {
             try{
                 await channel.permissionOverwrites.set(permissions)
             }catch{
-                openticket.log("Failed to reset channel permissions on ticket move!","error")
+                opendiscord.log("Failed to reset channel permissions on ticket move!","error")
             }
 
             //handle participants
@@ -151,59 +151,60 @@ export const registerActions = async () => {
                 const id = permission.id as string
                 participants.push({type,id})
             })
-            ticket.get("openticket:participants").value = participants
+            ticket.get("opendiscord:participants").value = participants
-            ticket.get("openticket:participants").refreshDatabase()
+            ticket.get("opendiscord:participants").refreshDatabase()
 
             //rename channel (and give error when crashed)
             const originalName = channel.name
             try{
                 await utilities.timedAwait(channel.setName(channelName),2500,(err) => {
-                    openticket.log("Failed to rename channel on ticket move","error")
+                    opendiscord.log("Failed to rename channel on ticket move","error")
                 })
             }catch(err){
-                await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-move",{guild,channel,user,originalName,newName:channelName})).message)
+                await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-move",{guild,channel,user,originalName,newName:channelName})).message)
             }
             try{
                 if (channel.type == discord.ChannelType.GuildText) channel.setTopic(channelDescription)
             }catch{}
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket renaming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket renaming!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:move-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:move-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketMoved").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketMoved").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.moving.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.moving.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.moving.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"move",reason,additionalData:data}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" moved a ticket!","info",[
+            opendiscord.log(user.displayName+" moved a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -213,8 +214,8 @@ export const registerActions = async () => {
             ])
         })
     ])
-    openticket.actions.get("openticket:move-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:move-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/actions/pinTicket.ts

@@ -1,29 +1,29 @@
 ///////////////////////////////////////
 //TICKET PINNING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:pin-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:pin-ticket"))
-    openticket.actions.get("openticket:pin-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:pin-ticket").workers.add([
-        new api.ODWorker("openticket:pin-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to pin ticket! Open Ticket doesn't support threads!")
             
-            await openticket.events.get("onTicketPin").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketPin").emit([ticket,user,channel,reason])
 
             //update ticket
-            ticket.get("openticket:pinned").value = true
+            ticket.get("opendiscord:pinned").value = true
-            ticket.get("openticket:pinned-by").value = user.id
+            ticket.get("opendiscord:pinned-by").value = user.id
-            ticket.get("openticket:pinned-on").value = new Date().getTime()
+            ticket.get("opendiscord:pinned-on").value = new Date().getTime()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
             
             //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-pinned",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-pinned",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-pinned",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-pinned",user.id,1,"increase")
 
             //move to top of category
             if (channel.parent){
@@ -35,49 +35,50 @@ export const registerActions = async () => {
             const newName = "📌"+channel.name
             try{
                 await utilities.timedAwait(channel.setName(newName),2500,(err) => {
-                    openticket.log("Failed to rename channel on ticket pin","error")
+                    opendiscord.log("Failed to rename channel on ticket pin","error")
                 })
             }catch(err){
-                await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-pin",{guild,channel,user,originalName,newName})).message)
+                await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-pin",{guild,channel,user,originalName,newName})).message)
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket pinning!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket pinning!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"message",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:pin-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketPinned").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketPinned").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.pinning.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.pinning.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.pinning.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"pin",reason,additionalData:null}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" pinned a ticket!","info",[
+            opendiscord.log(user.displayName+" pinned a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -91,184 +92,184 @@ export const registerActions = async () => {
 
 export const registerVerifyBars = async () => {
     //PIN TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:pin-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:pin-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:pin-ticket-ticket-message").success.add([
+    opendiscord.verifybars.get("opendiscord:pin-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.pin
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already pinned
-            if (ticket.get("openticket:pinned").value){
+            if (ticket.get("opendiscord:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start pinning ticket
             if (params.data == "reason"){
                 //pin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:pin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:pin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
             }else{
                 //pin without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:pin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:pin-ticket-ticket-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:pin-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 
     //PIN TICKET UNPIN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:pin-ticket-unpin-message",openticket.builders.messages.getSafe("openticket:verifybar-unpin-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:pin-ticket-unpin-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-unpin-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:pin-ticket-unpin-message").success.add([
+    opendiscord.verifybars.get("opendiscord:pin-ticket-unpin-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.pin
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already pinned
-            if (ticket.get("openticket:pinned").value){
+            if (ticket.get("opendiscord:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start pinning ticket
             if (params.data == "reason"){
                 //pin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:pin-ticket-reason").build("unpin-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:pin-ticket-reason").build("unpin-message",{guild,channel,user,ticket}))
             }else{
                 //pin without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run("unpin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:pin-ticket").run("unpin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:pin-message").build("unpin-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build("unpin-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:pin-ticket-unpin-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:pin-ticket-unpin-message").failure.add([
-        new api.ODWorker("openticket:back-to-unpin-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-unpin-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:unpin-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
-    openticket.actions.get("openticket:pin-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:pin-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/actions/reactionRole.ts

@@ -1,38 +1,38 @@
 ///////////////////////////////////////
 //REACTION ROLE SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:reaction-role"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:reaction-role"))
-    openticket.actions.get("openticket:reaction-role").workers.add([
+    opendiscord.actions.get("opendiscord:reaction-role").workers.add([
-        new api.ODWorker("openticket:reaction-role",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reaction-role",2,async (instance,params,source,cancel) => {
             const {guild,user,option,overwriteMode} = params
-            const role = openticket.roles.get(option.id)
+            const role = opendiscord.roles.get(option.id)
             if (!role) throw new api.ODSystemError("ODAction(ot:reaction-role) => Unknown reaction role (ODRole)")
             instance.role = role
-            const mode = (overwriteMode) ? overwriteMode : role.get("openticket:mode").value
+            const mode = (overwriteMode) ? overwriteMode : role.get("opendiscord:mode").value
             
-            await openticket.events.get("onRoleUpdate").emit([user,role])
+            await opendiscord.events.get("onRoleUpdate").emit([user,role])
 
             //get guild member
-            const member = await openticket.client.fetchGuildMember(guild,user.id)
+            const member = await opendiscord.client.fetchGuildMember(guild,user.id)
             if (!member) throw new api.ODSystemError("ODAction(ot:reaction-role) => User isn't a member of the server!")
 
             //get all roles
-            const roleIds = role.get("openticket:roles").value
+            const roleIds = role.get("opendiscord:roles").value
             const roles: discord.Role[] = []
             for (const id of roleIds){
-                const r = await openticket.client.fetchGuildRole(guild,id)
+                const r = await opendiscord.client.fetchGuildRole(guild,id)
                 if (r) roles.push(r)
-                else openticket.log("Unable to find role in server!","warning",[
+                else opendiscord.log("Unable to find role in server!","warning",[
                     {key:"roleid",value:id}
                 ])
             }
 
             //update roles of user
-            const result: api.OTRoleUpdateResult[] = []
+            const result: api.ODRoleUpdateResult[] = []
             for (const r of roles){
                 try{
                     if (r.members.has(user.id) && (mode == "add&remove" || mode == "remove")){
@@ -55,12 +55,12 @@ export const registerActions = async () => {
             //get roles to remove on add
             if (result.find((r) => r.action == "added")){
                 //get all remove roles
-                const removeRoleIds = role.get("openticket:remove-roles-on-add").value
+                const removeRoleIds = role.get("opendiscord:remove-roles-on-add").value
                 const removeRoles: discord.Role[] = []
                 for (const id of removeRoleIds){
-                    const r = await openticket.client.fetchGuildRole(guild,id)
+                    const r = await opendiscord.client.fetchGuildRole(guild,id)
                     if (r) removeRoles.push(r)
-                    else openticket.log("Unable to find role in server!","warning",[
+                    else opendiscord.log("Unable to find role in server!","warning",[
                         {key:"roleid",value:id}
                     ])
                 }
@@ -79,11 +79,11 @@ export const registerActions = async () => {
 
             //update instance & finish event
             instance.result = result
-            await openticket.events.get("afterRolesUpdated").emit([user,role])
+            await opendiscord.events.get("afterRolesUpdated").emit([user,role])
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,user,option} = params
-            openticket.log(user.displayName+" updated his roles!","info",[
+            opendiscord.log(user.displayName+" updated his roles!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"method",value:source},

src/actions/removeTicketUser.ts

@@ -1,70 +1,71 @@
 ///////////////////////////////////////
 //TICKET REMOVE USER SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:remove-ticket-user"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:remove-ticket-user"))
-    openticket.actions.get("openticket:remove-ticket-user").workers.add([
+    opendiscord.actions.get("opendiscord:remove-ticket-user").workers.add([
-        new api.ODWorker("openticket:remove-ticket-user",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:remove-ticket-user",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to remove user from ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketUserRemove").emit([ticket,user,data,channel,reason])
+            await opendiscord.events.get("onTicketUserRemove").emit([ticket,user,data,channel,reason])
             
             //update ticket
-            const index = ticket.get("openticket:participants").value.findIndex((p) => p.type == "user" && p.id == data.id)
+            const index = ticket.get("opendiscord:participants").value.findIndex((p) => p.type == "user" && p.id == data.id)
             if (index < 0) return cancel()
-            ticket.get("openticket:participants").value.splice(index,1)
+            ticket.get("opendiscord:participants").value.splice(index,1)
-            ticket.get("openticket:participants").refreshDatabase()
+            ticket.get("opendiscord:participants").refreshDatabase()
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //update channel permissions
             try{
                 await channel.permissionOverwrites.delete(data)
             }catch{
-                openticket.log("Failed to remove channel permission overwrites on remove-ticket-user","error")
+                opendiscord.log("Failed to remove channel permission overwrites on remove-ticket-user","error")
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket user removal!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket user removal!","error",[
                         {key:"channel",value:channel.id},
                         {key:"message",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:remove-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:remove-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketUserRemoved").emit([ticket,user,data,channel,reason])
+            await opendiscord.events.get("afterTicketUserRemoved").emit([ticket,user,data,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.removing.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.removing.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.removing.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"remove",reason,additionalData:data}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket,data} = params
 
-            openticket.log(user.displayName+" removed "+data.displayName+" from a ticket!","info",[
+            opendiscord.log(user.displayName+" removed "+data.displayName+" from a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -74,8 +75,8 @@ export const registerActions = async () => {
             ])
         })
     ])
-    openticket.actions.get("openticket:remove-ticket-user").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:remove-ticket-user").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/actions/renameTicket.ts

@@ -1,67 +1,68 @@
 ///////////////////////////////////////
 //TICKET RENAMING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:rename-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:rename-ticket"))
-    openticket.actions.get("openticket:rename-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:rename-ticket").workers.add([
-        new api.ODWorker("openticket:rename-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:rename-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to rename ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketRename").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketRename").emit([ticket,user,channel,reason])
 
             //rename channel (and give error when crashed)
             const originalName = channel.name
             try{
                 await utilities.timedAwait(channel.setName(data),2500,(err) => {
-                    openticket.log("Failed to rename channel on ticket rename","error")
+                    opendiscord.log("Failed to rename channel on ticket rename","error")
                 })
             }catch(err){
-                await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-rename",{guild,channel,user,originalName,newName:data})).message)
+                await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-rename",{guild,channel,user,originalName,newName:data})).message)
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket renaming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket renaming!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:rename-message").build(source,{guild,channel,user,ticket,reason,data})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:rename-message").build(source,{guild,channel,user,ticket,reason,data})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketRenamed").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketRenamed").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason,data} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.renaming.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.renaming.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.renaming.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"rename",reason,additionalData:data}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" renamed a ticket!","info",[
+            opendiscord.log(user.displayName+" renamed a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -71,8 +72,8 @@ export const registerActions = async () => {
             ])
         })
     ])
-    openticket.actions.get("openticket:rename-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:rename-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/actions/reopenTicket.ts

@@ -1,80 +1,82 @@
 ///////////////////////////////////////
 //TICKET REOPENING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:reopen-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:reopen-ticket"))
-    openticket.actions.get("openticket:reopen-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:reopen-ticket").workers.add([
-        new api.ODWorker("openticket:reopen-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to reopen ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketReopen").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketReopen").emit([ticket,user,channel,reason])
 
             //update ticket
-            ticket.get("openticket:closed").value = false
+            ticket.get("opendiscord:closed").value = false
-            ticket.get("openticket:open").value = true
+            ticket.get("opendiscord:open").value = true
-            ticket.get("openticket:autoclosed").value = false
+            ticket.get("opendiscord:autoclosed").value = false
-            ticket.get("openticket:closed-by").value = null
+            ticket.get("opendiscord:closed-by").value = null
-            ticket.get("openticket:closed-on").value = null
+            ticket.get("opendiscord:closed-on").value = null
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //update stats
-            await openticket.stats.get("openticket:global").setStat("openticket:tickets-reopened",1,"increase")
+            await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:tickets-reopened",1,"increase")
-            await openticket.stats.get("openticket:user").setStat("openticket:tickets-reopened",user.id,1,"increase")
+            await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:tickets-reopened",user.id,1,"increase")
 
             //update category
-            const channelCategory = ticket.option.get("openticket:channel-category").value
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
-            const channelBackupCategory = ticket.option.get("openticket:channel-category-backup").value
+                const channelCategory = ticket.option.get("opendiscord:channel-category").value
-            if (channelCategory !== ""){
+                const channelBackupCategory = ticket.option.get("opendiscord:channel-category-backup").value
-                //category enabled
+                if (channelCategory !== ""){
-                try {
+                    //category enabled
-                    const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
+                    try {
-                    if (!normalCategory){
+                        const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
-                        //default category was not found
+                        if (!normalCategory){
-                        openticket.log("Ticket Reopening Error: Unable to find category! #1","error",[
+                            //default category was not found
-                            {key:"categoryid",value:channelCategory},
+                            opendiscord.log("Ticket Reopening Error: Unable to find category! #1","error",[
-                            {key:"backup",value:"false"}
+                                {key:"categoryid",value:channelCategory},
-                        ])
+                                {key:"backup",value:"false"}
-                    }else{
+                            ])
-                        //default category was found
-                        if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
-                            //use backup category
-                            const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
-                            if (!backupCategory){
-                                //default category was not found
-                                openticket.log("Ticket Reopening Error: Unable to find category! #2","error",[
-                                    {key:"categoryid",value:channelBackupCategory},
-                                    {key:"backup",value:"true"}
-                                ])
-                            }else{
-                                //use backup category
-                                channel.setParent(backupCategory,{lockPermissions:false})
-                                ticket.get("openticket:category-mode").value = "backup"
-                                ticket.get("openticket:category").value = backupCategory.id
-                            }
                         }else{
-                            //use default category
+                            //default category was found
-                            channel.setParent(normalCategory,{lockPermissions:false})
+                            if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
-                            ticket.get("openticket:category-mode").value = "normal"
+                                //use backup category
-                            ticket.get("openticket:category").value = normalCategory.id
+                                const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                                if (!backupCategory){
+                                    //default category was not found
+                                    opendiscord.log("Ticket Reopening Error: Unable to find category! #2","error",[
+                                        {key:"categoryid",value:channelBackupCategory},
+                                        {key:"backup",value:"true"}
+                                    ])
+                                }else{
+                                    //use backup category
+                                    channel.setParent(backupCategory,{lockPermissions:false})
+                                    ticket.get("opendiscord:category-mode").value = "backup"
+                                    ticket.get("opendiscord:category").value = backupCategory.id
+                                }
+                            }else{
+                                //use default category
+                                channel.setParent(normalCategory,{lockPermissions:false})
+                                ticket.get("opendiscord:category-mode").value = "normal"
+                                ticket.get("opendiscord:category").value = normalCategory.id
+                            }
                         }
+                    }catch(e){
+                        opendiscord.log("Unable to move ticket to 'reopened category'!","error",[
+                            {key:"channel",value:"#"+channel.name},
+                            {key:"channelid",value:channel.id,hidden:true},
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                     }
-                }catch(e){
+                }else{
-                    openticket.log("Unable to move ticket to 'reopened category'!","error",[
+                    channel.setParent(null,{lockPermissions:false})
-                        {key:"channel",value:"#"+channel.name},
+                    ticket.get("opendiscord:category-mode").value = null
-                        {key:"channelid",value:channel.id,hidden:true},
+                    ticket.get("opendiscord:category").value = null
-                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
-            }else{
-                channel.setParent(null,{lockPermissions:false})
-                ticket.get("openticket:category-mode").value = null
-                ticket.get("openticket:category").value = null
             }
 
             //update permissions
@@ -84,9 +86,9 @@ export const registerActions = async () => {
                 allow:[],
                 deny:["ViewChannel","SendMessages","ReadMessageHistory"]
             }]
-            const globalAdmins = openticket.configs.get("openticket:general").data.globalAdmins
+            const globalAdmins = opendiscord.configs.get("opendiscord:general").data.globalAdmins
-            const optionAdmins = ticket.option.get("openticket:admins").value
+            const optionAdmins = ticket.option.get("opendiscord:admins").value
-            const readonlyAdmins = ticket.option.get("openticket:admins-readonly").value
+            const readonlyAdmins = ticket.option.get("opendiscord:admins-readonly").value
 
             globalAdmins.forEach((admin) => {
                 permissions.push({
@@ -115,7 +117,7 @@ export const registerActions = async () => {
                     deny:["SendMessages","AddReactions","AttachFiles","SendPolls"]
                 })
             })
-            ticket.get("openticket:participants").value.forEach((participant) => {
+            ticket.get("opendiscord:participants").value.forEach((participant) => {
                 //all participants that aren't roles/admins
                 if (participant.type == "user"){
                     permissions.push({
@@ -129,41 +131,42 @@ export const registerActions = async () => {
             channel.permissionOverwrites.set(permissions)
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket reopening!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket reopening!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:reopen-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketReopened").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketReopened").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.reopening.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.reopening.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.reopening.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"reopen",reason,additionalData:null}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" reopened a ticket!","info",[
+            opendiscord.log(user.displayName+" reopened a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -177,272 +180,272 @@ export const registerActions = async () => {
 
 export const registerVerifyBars = async () => {
     //REOPEN TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:reopen-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:reopen-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:reopen-ticket-ticket-message").success.add([
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.reopen
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when not closed
-            if (!ticket.get("openticket:closed").value){
+            if (!ticket.get("opendiscord:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start reopening ticket
             if (params.data == "reason"){
                 //reopen with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:reopen-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:reopen-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
             }else{
                 //reopen without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:reopen-ticket-ticket-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 
     //REOPEN TICKET CLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:reopen-ticket-close-message",openticket.builders.messages.getSafe("openticket:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:reopen-ticket-close-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-close-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:reopen-ticket-close-message").success.add([
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-close-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.reopen
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when not closed
-            if (!ticket.get("openticket:closed").value){
+            if (!ticket.get("opendiscord:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start reopening ticket
             if (params.data == "reason"){
                 //reopen with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:reopen-ticket-reason").build("close-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:reopen-ticket-reason").build("close-message",{guild,channel,user,ticket}))
             }else{
                 //reopen without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run("close-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("close-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("close-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:reopen-ticket-close-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-close-message").failure.add([
-        new api.ODWorker("openticket:back-to-close-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-close-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
 
     //REOPEN TICKET AUTOCLOSE MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:reopen-ticket-autoclose-message",openticket.builders.messages.getSafe("openticket:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:reopen-ticket-autoclose-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-autoclose-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:reopen-ticket-autoclose-message").success.add([
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-autoclose-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.reopen
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when not closed
-            if (!ticket.get("openticket:closed").value){
+            if (!ticket.get("opendiscord:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.reopen"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start reopening ticket
             if (params.data == "reason"){
                 //reopen with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:reopen-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:reopen-ticket-reason").build("autoclose-message",{guild,channel,user,ticket}))
             }else{
                 //reopen without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:reopen-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:reopen-ticket").run("autoclose-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:reopen-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:reopen-message").build("autoclose-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:reopen-ticket-autoclose-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:reopen-ticket-autoclose-message").failure.add([
-        new api.ODWorker("openticket:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-autoclose-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:autoclose-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-message").build("other",{guild,channel,user,ticket}))
         })
     ])
-    openticket.actions.get("openticket:reopen-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:reopen-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/actions/unclaimTicket.ts

@@ -1,114 +1,117 @@
 ///////////////////////////////////////
 //TICKET UNCLAIMING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:unclaim-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:unclaim-ticket"))
-    openticket.actions.get("openticket:unclaim-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:unclaim-ticket").workers.add([
-        new api.ODWorker("openticket:unclaim-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unclaim-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to unclaim ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketUnclaim").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketUnclaim").emit([ticket,user,channel,reason])
 
             //update ticket
-            ticket.get("openticket:claimed").value = false
+            ticket.get("opendiscord:claimed").value = false
-            ticket.get("openticket:claimed-by").value = null
+            ticket.get("opendiscord:claimed-by").value = null
-            ticket.get("openticket:claimed-on").value = null
+            ticket.get("opendiscord:claimed-on").value = null
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //update category
-            const channelCategory = ticket.option.get("openticket:channel-category").value
+            if (typeof params.allowCategoryChange == "boolean" ? params.allowCategoryChange : true){
-            const channelBackupCategory = ticket.option.get("openticket:channel-category-backup").value
+                const channelCategory = ticket.option.get("opendiscord:channel-category").value
-            if (channelCategory !== ""){
+                const channelBackupCategory = ticket.option.get("opendiscord:channel-category-backup").value
-                //category enabled
+                if (channelCategory !== ""){
-                try {
+                    //category enabled
-                    const normalCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelCategory)
+                    try {
-                    if (!normalCategory){
+                        const normalCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelCategory)
-                        //default category was not found
+                        if (!normalCategory){
-                        openticket.log("Ticket Unclaiming Error: Unable to find category! #1","error",[
+                            //default category was not found
-                            {key:"categoryid",value:channelCategory},
+                            opendiscord.log("Ticket Unclaiming Error: Unable to find category! #1","error",[
-                            {key:"backup",value:"false"}
+                                {key:"categoryid",value:channelCategory},
-                        ])
+                                {key:"backup",value:"false"}
-                    }else{
+                            ])
-                        //default category was found
-                        if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
-                            //use backup category
-                            const backupCategory = await openticket.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
-                            if (!backupCategory){
-                                //default category was not found
-                                openticket.log("Ticket Unclaiming Error: Unable to find category! #2","error",[
-                                    {key:"categoryid",value:channelBackupCategory},
-                                    {key:"backup",value:"true"}
-                                ])
-                            }else{
-                                //use backup category
-                                channel.setParent(backupCategory,{lockPermissions:false})
-                                ticket.get("openticket:category-mode").value = "backup"
-                                ticket.get("openticket:category").value = backupCategory.id
-                            }
                         }else{
-                            //use default category
+                            //default category was found
-                            channel.setParent(normalCategory,{lockPermissions:false})
+                            if (normalCategory.children.cache.size >= 49 && channelBackupCategory != ""){
-                            ticket.get("openticket:category-mode").value = "normal"
+                                //use backup category
-                            ticket.get("openticket:category").value = normalCategory.id
+                                const backupCategory = await opendiscord.client.fetchGuildCategoryChannel(guild,channelBackupCategory)
+                                if (!backupCategory){
+                                    //default category was not found
+                                    opendiscord.log("Ticket Unclaiming Error: Unable to find category! #2","error",[
+                                        {key:"categoryid",value:channelBackupCategory},
+                                        {key:"backup",value:"true"}
+                                    ])
+                                }else{
+                                    //use backup category
+                                    channel.setParent(backupCategory,{lockPermissions:false})
+                                    ticket.get("opendiscord:category-mode").value = "backup"
+                                    ticket.get("opendiscord:category").value = backupCategory.id
+                                }
+                            }else{
+                                //use default category
+                                channel.setParent(normalCategory,{lockPermissions:false})
+                                ticket.get("opendiscord:category-mode").value = "normal"
+                                ticket.get("opendiscord:category").value = normalCategory.id
+                            }
                         }
+                        
+                    }catch(e){
+                        opendiscord.log("Unable to move ticket to 'unclaimed category'!","error",[
+                            {key:"channel",value:"#"+channel.name},
+                            {key:"channelid",value:channel.id,hidden:true}
+                        ])
+                        opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                     }
-                    
+                }else{
-                }catch(e){
+                    channel.setParent(null,{lockPermissions:false})
-                    openticket.log("Unable to move ticket to 'unclaimed category'!","error",[
+                    ticket.get("opendiscord:category-mode").value = null
-                        {key:"channel",value:"#"+channel.name},
+                    ticket.get("opendiscord:category").value = null
-                        {key:"channelid",value:channel.id,hidden:true}
-                    ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
-            }else{
-                channel.setParent(null,{lockPermissions:false})
-                ticket.get("openticket:category-mode").value = null
-                ticket.get("openticket:category").value = null
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket unclaiming!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket unclaiming!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:unclaim-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketUnclaimed").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketUnclaimed").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.claiming.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.claiming.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.claiming.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unclaim",reason,additionalData:null}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" unclaimed a ticket!","info",[
+            opendiscord.log(user.displayName+" unclaimed a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -122,184 +125,184 @@ export const registerActions = async () => {
 
 export const registerVerifyBars = async () => {
     //UNCLAIM TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unclaim-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unclaim-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unclaim-ticket-ticket-message").success.add([
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.unclaim
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:unclaim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unclaim-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when not claimed
-            if (!ticket.get("openticket:claimed").value){
+            if (!ticket.get("opendiscord:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start unclaiming ticket
             if (params.data == "reason"){
                 //unclaim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unclaim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unclaim-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
             }else{
                 //unclaim without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:unclaim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:unclaim-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:unclaim-ticket-ticket-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 
     //UNCLAIM TICKET CLAIM MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unclaim-ticket-claim-message",openticket.builders.messages.getSafe("openticket:verifybar-claim-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unclaim-ticket-claim-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-claim-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unclaim-ticket-claim-message").success.add([
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-claim-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.unclaim
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:unclaim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unclaim-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when not claimed
-            if (!ticket.get("openticket:claimed").value){
+            if (!ticket.get("opendiscord:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unclaim"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start unclaiming ticket
             if (params.data == "reason"){
                 //unclaim with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unclaim-ticket-reason").build("claim-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unclaim-ticket-reason").build("claim-message",{guild,channel,user,ticket}))
             }else{
                 //unclaim without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:unclaim-ticket").run("claim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:unclaim-ticket").run("claim-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:unclaim-message").build("claim-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unclaim-message").build("claim-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:unclaim-ticket-claim-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:unclaim-ticket-claim-message").failure.add([
-        new api.ODWorker("openticket:back-to-claim-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-claim-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:claim-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
-    openticket.actions.get("openticket:unclaim-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:unclaim-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/actions/unpinTicket.ts

@@ -1,25 +1,25 @@
 ///////////////////////////////////////
 //TICKET UNPINNING SYSTEM
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerActions = async () => {
-    openticket.actions.add(new api.ODAction("openticket:unpin-ticket"))
+    opendiscord.actions.add(new api.ODAction("opendiscord:unpin-ticket"))
-    openticket.actions.get("openticket:unpin-ticket").workers.add([
+    opendiscord.actions.get("opendiscord:unpin-ticket").workers.add([
-        new api.ODWorker("openticket:unpin-ticket",2,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unpin-ticket",2,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
             if (channel.isThread()) throw new api.ODSystemError("Unable to unpin ticket! Open Ticket doesn't support threads!")
 
-            await openticket.events.get("onTicketUnpin").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("onTicketUnpin").emit([ticket,user,channel,reason])
             
             //update ticket
-            ticket.get("openticket:pinned").value = false
+            ticket.get("opendiscord:pinned").value = false
-            ticket.get("openticket:pinned-by").value = null
+            ticket.get("opendiscord:pinned-by").value = null
-            ticket.get("openticket:pinned-on").value = null
+            ticket.get("opendiscord:pinned-on").value = null
-            ticket.get("openticket:busy").value = true
+            ticket.get("opendiscord:busy").value = true
 
             //rename channel (and give error when crashed)
             const originalName = channel.name
@@ -27,50 +27,51 @@ export const registerActions = async () => {
                 const newName = originalName.replace("📌","");
                 try{
                     await utilities.timedAwait(channel.setName(newName),2500,(err) => {
-                        openticket.log("Failed to rename channel on ticket unpin","error")
+                        opendiscord.log("Failed to rename channel on ticket unpin","error")
                     })
                 }catch(err){
-                    await channel.send((await openticket.builders.messages.getSafe("openticket:error-channel-rename").build("ticket-unpin",{guild,channel,user,originalName,newName})).message)
+                    await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:error-channel-rename").build("ticket-unpin",{guild,channel,user,originalName,newName})).message)
                 }
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on ticket unpinning!","error",[
+                    opendiscord.log("Unable to edit ticket message on ticket unpinning!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
 
             //reply with new message
-            if (params.sendMessage) await channel.send((await openticket.builders.messages.getSafe("openticket:unpin-message").build(source,{guild,channel,user,ticket,reason})).message)
+            if (params.sendMessage) await channel.send((await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build(source,{guild,channel,user,ticket,reason})).message)
-            ticket.get("openticket:busy").value = false
+            ticket.get("opendiscord:busy").value = false
-            await openticket.events.get("afterTicketUnpinned").emit([ticket,user,channel,reason])
+            await opendiscord.events.get("afterTicketUnpinned").emit([ticket,user,channel,reason])
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user,ticket,reason} = params
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.pinning.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-logs").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.pinning.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
+            const creator = await opendiscord.tickets.getTicketUser(ticket,"creator")
+            if (creator && generalConfig.data.system.messages.pinning.dm) await opendiscord.client.sendUserDm(creator,await opendiscord.builders.messages.getSafe("opendiscord:ticket-action-dm").build(source,{guild,channel,user,ticket,mode:"unpin",reason,additionalData:null}))
         }),
-        new api.ODWorker("openticket:logs",0,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",0,(instance,params,source,cancel) => {
             const {guild,channel,user,ticket} = params
 
-            openticket.log(user.displayName+" unpinned a ticket!","info",[
+            opendiscord.log(user.displayName+" unpinned a ticket!","info",[
                 {key:"user",value:user.username},
                 {key:"userid",value:user.id,hidden:true},
                 {key:"channel",value:"#"+channel.name},
@@ -84,184 +85,184 @@ export const registerActions = async () => {
 
 export const registerVerifyBars = async () => {
     //UNPIN TICKET TICKET MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unpin-ticket-ticket-message",openticket.builders.messages.getSafe("openticket:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unpin-ticket-ticket-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-ticket-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unpin-ticket-ticket-message").success.add([
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-ticket-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.unpin
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:unpin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unpin-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when not pinned
-            if (!ticket.get("openticket:pinned").value){
+            if (!ticket.get("opendiscord:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start unpining ticket
             if (params.data == "reason"){
                 //unpin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unpin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unpin-ticket-reason").build("ticket-message",{guild,channel,user,ticket}))
             }else{
                 //unpin without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:unpin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:unpin-ticket").run("ticket-message",{guild,channel,user,ticket,reason:null,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:unpin-ticket-ticket-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-ticket-message").failure.add([
-        new api.ODWorker("openticket:back-to-ticket-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-ticket-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
         })
     ])
 
     //UNPIN TICKET PIN MESSAGE
-    openticket.verifybars.add(new api.ODVerifyBar("openticket:unpin-ticket-pin-message",openticket.builders.messages.getSafe("openticket:verifybar-pin-message"),!generalConfig.data.system.disableVerifyBars))
+    opendiscord.verifybars.add(new api.ODVerifyBar("opendiscord:unpin-ticket-pin-message",opendiscord.builders.messages.getSafe("opendiscord:verifybar-pin-message"),!generalConfig.data.system.disableVerifyBars))
-    openticket.verifybars.get("openticket:unpin-ticket-pin-message").success.add([
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-pin-message").success.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.unpin
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:unpin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:unpin-ticket",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when not pinned
-            if (!ticket.get("openticket:pinned").value){
+            if (!ticket.get("opendiscord:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.unpin"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             //start unpinning ticket
             if (params.data == "reason"){
                 //unpin with reason
-                instance.modal(await openticket.builders.modals.getSafe("openticket:unpin-ticket-reason").build("pin-message",{guild,channel,user,ticket}))
+                instance.modal(await opendiscord.builders.modals.getSafe("opendiscord:unpin-ticket-reason").build("pin-message",{guild,channel,user,ticket}))
             }else{
                 //unpin without reason
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:unpin-ticket").run("pin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:unpin-ticket").run("pin-message",{guild,channel,user,ticket,reason:null,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:unpin-message").build("pin-message",{guild,channel,user,ticket,reason:null}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:unpin-message").build("pin-message",{guild,channel,user,ticket,reason:null}))
             }
         })
     ])
-    openticket.verifybars.get("openticket:unpin-ticket-pin-message").failure.add([
+    opendiscord.verifybars.get("opendiscord:unpin-ticket-pin-message").failure.add([
-        new api.ODWorker("openticket:back-to-pin-message",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:back-to-pin-message",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             const {verifybarMessage} = params
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const rawReason = (verifybarMessage && verifybarMessage.embeds[0] && verifybarMessage.embeds[0].fields[0]) ? verifybarMessage.embeds[0].fields[0].value : null
             const reason = (rawReason == null) ? null : rawReason.substring(3,rawReason.length-3)
 
-            await instance.update(await openticket.builders.messages.getSafe("openticket:pin-message").build("other",{guild,channel,user,ticket,reason}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build("other",{guild,channel,user,ticket,reason}))
         })
     ])
-    openticket.actions.get("openticket:unpin-ticket").workers.backupWorker = new api.ODWorker("openticket:cancel-busy",0,(instance,params) => {
+    opendiscord.actions.get("opendiscord:unpin-ticket").workers.backupWorker = new api.ODWorker("opendiscord:cancel-busy",0,(instance,params) => {
         //set busy to false in case of crash or cancel
-        params.ticket.get("openticket:busy").value = false
+        params.ticket.get("opendiscord:busy").value = false
     })
 }

src/builders/buttons.ts

@@ -1,12 +1,12 @@
 ///////////////////////////////////////
 //BUTTON BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const buttons = openticket.builders.buttons
+const buttons = opendiscord.builders.buttons
-const lang = openticket.languages
+const lang = opendiscord.languages
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerAllButtons = async () => {
     verifybarButtons()
@@ -20,12 +20,12 @@ export const registerAllButtons = async () => {
 
 const verifybarButtons = () => {
     //VERIFYBAR SUCCESS
-    buttons.add(new api.ODButton("openticket:verifybar-success"))
+    buttons.add(new api.ODButton("opendiscord:verifybar-success"))
-    buttons.get("openticket:verifybar-success").workers.add(
+    buttons.get("opendiscord:verifybar-success").workers.add(
-        new api.ODWorker("openticket:verifybar-success",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:verifybar-success",0,async (instance,params) => {
             const {verifybar,customData,customColor,customLabel,customEmoji} = params
 
-            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:openticket:verifybar-success => customData exceeds 40 characters limit!")
+            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:opendiscord:verifybar-success => customData exceeds 40 characters limit!")
 
             const newData = (customData) ? "_"+customData : ""
             const newColor = customColor ?? "gray"
@@ -41,12 +41,12 @@ const verifybarButtons = () => {
     )
 
     //VERIFYBAR FAILURE
-    buttons.add(new api.ODButton("openticket:verifybar-failure"))
+    buttons.add(new api.ODButton("opendiscord:verifybar-failure"))
-    buttons.get("openticket:verifybar-failure").workers.add(
+    buttons.get("opendiscord:verifybar-failure").workers.add(
-        new api.ODWorker("openticket:verifybar-failure",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:verifybar-failure",0,async (instance,params) => {
             const {verifybar,customData,customColor,customLabel,customEmoji} = params
 
-            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:openticket:verifybar-success => customData exceeds 40 characters limit!")
+            if (customData && customData.length > 40) throw new api.ODSystemError("ODButton:opendiscord:verifybar-success => customData exceeds 40 characters limit!")
 
             const newData = (customData) ? "_"+customData : ""
             const newColor = customColor ?? "gray"
@@ -64,9 +64,9 @@ const verifybarButtons = () => {
 
 const errorButtons = () => {
     //ERROR TICKET DEPRECATED TRANSCRIPT
-    buttons.add(new api.ODButton("openticket:error-ticket-deprecated-transcript"))
+    buttons.add(new api.ODButton("opendiscord:error-ticket-deprecated-transcript"))
-    buttons.get("openticket:error-ticket-deprecated-transcript").workers.add(
+    buttons.get("opendiscord:error-ticket-deprecated-transcript").workers.add(
-        new api.ODWorker("openticket:error-ticket-deprecated-transcript",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:error-ticket-deprecated-transcript",0,async (instance,params) => {
             
             instance.setCustomId("od:error-ticket-deprecated-transcript")
             instance.setMode("button")
@@ -79,11 +79,11 @@ const errorButtons = () => {
 
 const helpMenuButtons = () => {
     //HELP MENU PAGE
-    buttons.add(new api.ODButton("openticket:help-menu-page"))
+    buttons.add(new api.ODButton("opendiscord:help-menu-page"))
-    buttons.get("openticket:help-menu-page").workers.add(
+    buttons.get("opendiscord:help-menu-page").workers.add(
-        new api.ODWorker("openticket:help-menu-page",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:help-menu-page",0,async (instance,params) => {
             const {mode,page} = params
-            const totalPages = (await openticket.helpmenu.render(mode)).length
+            const totalPages = (await opendiscord.helpmenu.render(mode)).length
             const pageText = (page+1).toString()+"/"+totalPages.toString()
 
             instance.setCustomId("od:help-menu-page_"+page.toString())
@@ -95,9 +95,9 @@ const helpMenuButtons = () => {
     )
 
     //HELP MENU SWITCH
-    buttons.add(new api.ODButton("openticket:help-menu-switch"))
+    buttons.add(new api.ODButton("opendiscord:help-menu-switch"))
-    buttons.get("openticket:help-menu-switch").workers.add(
+    buttons.get("opendiscord:help-menu-switch").workers.add(
-        new api.ODWorker("openticket:help-menu-switch",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:help-menu-switch",0,async (instance,params) => {
             const {mode} = params
 
             instance.setCustomId("od:help-menu-switch_"+mode)
@@ -109,9 +109,9 @@ const helpMenuButtons = () => {
     )
 
     //HELP MENU PREVIOUS
-    buttons.add(new api.ODButton("openticket:help-menu-previous"))
+    buttons.add(new api.ODButton("opendiscord:help-menu-previous"))
-    buttons.get("openticket:help-menu-previous").workers.add(
+    buttons.get("opendiscord:help-menu-previous").workers.add(
-        new api.ODWorker("openticket:help-menu-previous",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:help-menu-previous",0,async (instance,params) => {
             const {page} = params
             
             instance.setCustomId("od:help-menu-previous")
@@ -123,11 +123,11 @@ const helpMenuButtons = () => {
     )
 
     //HELP MENU NEXT
-    buttons.add(new api.ODButton("openticket:help-menu-next"))
+    buttons.add(new api.ODButton("opendiscord:help-menu-next"))
-    buttons.get("openticket:help-menu-next").workers.add(
+    buttons.get("opendiscord:help-menu-next").workers.add(
-        new api.ODWorker("openticket:help-menu-next",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:help-menu-next",0,async (instance,params) => {
             const {mode,page} = params
-            const totalPages = (await openticket.helpmenu.render(mode)).length
+            const totalPages = (await opendiscord.helpmenu.render(mode)).length
             
             instance.setCustomId("od:help-menu-next")
             instance.setMode("button")
@@ -140,55 +140,55 @@ const helpMenuButtons = () => {
 
 const panelButtons = () => {
     //TICKET OPTION
-    buttons.add(new api.ODButton("openticket:ticket-option"))
+    buttons.add(new api.ODButton("opendiscord:ticket-option"))
-    buttons.get("openticket:ticket-option").workers.add(
+    buttons.get("opendiscord:ticket-option").workers.add(
-        new api.ODWorker("openticket:ticket-option",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:ticket-option",0,async (instance,params) => {
             const {panel,option} = params
             
             instance.setCustomId("od:ticket-option_"+panel.id.value+"_"+option.id.value)
             instance.setMode("button")
-            instance.setColor(option.get("openticket:button-color").value)
+            instance.setColor(option.get("opendiscord:button-color").value)
-            if (option.get("openticket:button-emoji").value) instance.setEmoji(option.get("openticket:button-emoji").value)
+            if (option.get("opendiscord:button-emoji").value) instance.setEmoji(option.get("opendiscord:button-emoji").value)
-            if (option.get("openticket:button-label").value) instance.setLabel(option.get("openticket:button-label").value)
+            if (option.get("opendiscord:button-label").value) instance.setLabel(option.get("opendiscord:button-label").value)
-            if (!option.get("openticket:button-emoji").value && !option.get("openticket:button-label").value) instance.setLabel("<"+option.id.value+">")
+            if (!option.get("opendiscord:button-emoji").value && !option.get("opendiscord:button-label").value) instance.setLabel("<"+option.id.value+">")
         })
     )
 
     //WEBSITE OPTION
-    buttons.add(new api.ODButton("openticket:website-option"))
+    buttons.add(new api.ODButton("opendiscord:website-option"))
-    buttons.get("openticket:website-option").workers.add(
+    buttons.get("opendiscord:website-option").workers.add(
-        new api.ODWorker("openticket:website-option",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:website-option",0,async (instance,params) => {
             const {panel,option} = params
             
             instance.setMode("url")
-            instance.setUrl(option.get("openticket:url").value)
+            instance.setUrl(option.get("opendiscord:url").value)
-            if (option.get("openticket:button-emoji").value) instance.setEmoji(option.get("openticket:button-emoji").value)
+            if (option.get("opendiscord:button-emoji").value) instance.setEmoji(option.get("opendiscord:button-emoji").value)
-            if (option.get("openticket:button-label").value) instance.setLabel(option.get("openticket:button-label").value)
+            if (option.get("opendiscord:button-label").value) instance.setLabel(option.get("opendiscord:button-label").value)
-            if (!option.get("openticket:button-emoji").value && !option.get("openticket:button-label").value) instance.setLabel("<"+option.id.value+">")
+            if (!option.get("opendiscord:button-emoji").value && !option.get("opendiscord:button-label").value) instance.setLabel("<"+option.id.value+">")
         })
     )
 
     //ROLE OPTION
-    buttons.add(new api.ODButton("openticket:role-option"))
+    buttons.add(new api.ODButton("opendiscord:role-option"))
-    buttons.get("openticket:role-option").workers.add(
+    buttons.get("opendiscord:role-option").workers.add(
-        new api.ODWorker("openticket:role-option",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:role-option",0,async (instance,params) => {
             const {panel,option} = params
             
             instance.setCustomId("od:role-option_"+panel.id.value+"_"+option.id.value)
             instance.setMode("button")
-            instance.setColor(option.get("openticket:button-color").value)
+            instance.setColor(option.get("opendiscord:button-color").value)
-            if (option.get("openticket:button-emoji").value) instance.setEmoji(option.get("openticket:button-emoji").value)
+            if (option.get("opendiscord:button-emoji").value) instance.setEmoji(option.get("opendiscord:button-emoji").value)
-            if (option.get("openticket:button-label").value) instance.setLabel(option.get("openticket:button-label").value)
+            if (option.get("opendiscord:button-label").value) instance.setLabel(option.get("opendiscord:button-label").value)
-            if (!option.get("openticket:button-emoji").value && !option.get("openticket:button-label").value) instance.setLabel("<"+option.id.value+">")
+            if (!option.get("opendiscord:button-emoji").value && !option.get("opendiscord:button-label").value) instance.setLabel("<"+option.id.value+">")
         })
     )
 }
 
 const ticketButtons = () => {
     //VISIT TICKET
-    buttons.add(new api.ODButton("openticket:visit-ticket"))
+    buttons.add(new api.ODButton("opendiscord:visit-ticket"))
-    buttons.get("openticket:visit-ticket").workers.add(
+    buttons.get("opendiscord:visit-ticket").workers.add(
-        new api.ODWorker("openticket:visit-ticket",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:visit-ticket",0,async (instance,params) => {
             const {guild,channel,ticket} = params
             
             instance.setMode("url")
@@ -199,9 +199,9 @@ const ticketButtons = () => {
     )
 
     //CLOSE TICKET
-    buttons.add(new api.ODButton("openticket:close-ticket"))
+    buttons.add(new api.ODButton("opendiscord:close-ticket"))
-    buttons.get("openticket:close-ticket").workers.add(
+    buttons.get("opendiscord:close-ticket").workers.add(
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source) => {
             const {guild,channel,ticket} = params
 
             instance.setMode("button")
@@ -213,9 +213,9 @@ const ticketButtons = () => {
     )
 
     //DELETE TICKET
-    buttons.add(new api.ODButton("openticket:delete-ticket"))
+    buttons.add(new api.ODButton("opendiscord:delete-ticket"))
-    buttons.get("openticket:delete-ticket").workers.add(
+    buttons.get("opendiscord:delete-ticket").workers.add(
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source) => {
             const {guild,channel,ticket} = params
 
             instance.setMode("button")
@@ -227,9 +227,9 @@ const ticketButtons = () => {
     )
 
     //REOPEN TICKET
-    buttons.add(new api.ODButton("openticket:reopen-ticket"))
+    buttons.add(new api.ODButton("opendiscord:reopen-ticket"))
-    buttons.get("openticket:reopen-ticket").workers.add(
+    buttons.get("opendiscord:reopen-ticket").workers.add(
-        new api.ODWorker("openticket:reopen-ticket",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:reopen-ticket",0,async (instance,params,source) => {
             const {guild,channel,ticket} = params
 
             instance.setMode("button")
@@ -241,9 +241,9 @@ const ticketButtons = () => {
     )
 
     //CLAIM TICKET
-    buttons.add(new api.ODButton("openticket:claim-ticket"))
+    buttons.add(new api.ODButton("opendiscord:claim-ticket"))
-    buttons.get("openticket:claim-ticket").workers.add(
+    buttons.get("opendiscord:claim-ticket").workers.add(
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source) => {
             const {guild,channel,ticket} = params
 
             instance.setMode("button")
@@ -255,9 +255,9 @@ const ticketButtons = () => {
     )
 
     //UNCLAIM TICKET
-    buttons.add(new api.ODButton("openticket:unclaim-ticket"))
+    buttons.add(new api.ODButton("opendiscord:unclaim-ticket"))
-    buttons.get("openticket:unclaim-ticket").workers.add(
+    buttons.get("opendiscord:unclaim-ticket").workers.add(
-        new api.ODWorker("openticket:unclaim-ticket",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:unclaim-ticket",0,async (instance,params,source) => {
             const {guild,channel,ticket} = params
 
             instance.setMode("button")
@@ -269,9 +269,9 @@ const ticketButtons = () => {
     )
 
     //PIN TICKET
-    buttons.add(new api.ODButton("openticket:pin-ticket"))
+    buttons.add(new api.ODButton("opendiscord:pin-ticket"))
-    buttons.get("openticket:pin-ticket").workers.add(
+    buttons.get("opendiscord:pin-ticket").workers.add(
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source) => {
             const {guild,channel,ticket} = params
 
             instance.setMode("button")
@@ -283,9 +283,9 @@ const ticketButtons = () => {
     )
 
     //UNPIN TICKET
-    buttons.add(new api.ODButton("openticket:unpin-ticket"))
+    buttons.add(new api.ODButton("opendiscord:unpin-ticket"))
-    buttons.get("openticket:unpin-ticket").workers.add(
+    buttons.get("opendiscord:unpin-ticket").workers.add(
-        new api.ODWorker("openticket:unpin-ticket",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:unpin-ticket",0,async (instance,params,source) => {
             const {guild,channel,ticket} = params
 
             instance.setMode("button")
@@ -299,22 +299,22 @@ const ticketButtons = () => {
 
 const transcriptButtons = () => {
     //TRANSCRIPT HTML VISIT
-    buttons.add(new api.ODButton("openticket:transcript-html-visit"))
+    buttons.add(new api.ODButton("opendiscord:transcript-html-visit"))
-    buttons.get("openticket:transcript-html-visit").workers.add(
+    buttons.get("opendiscord:transcript-html-visit").workers.add(
-        new api.ODWorker("openticket:transcript-html-visit",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:transcript-html-visit",0,async (instance,params,source) => {
             const {result} = params
             instance.setMode("url")
             if (result.data) instance.setUrl(result.data.url)
-            else throw new api.ODSystemError("ODButton:openticket:transcript-html-visit => Missing Transcript Result Data!")
+            else throw new api.ODSystemError("ODButton:opendiscord:transcript-html-visit => Missing Transcript Result Data!")
             instance.setEmoji("📄")
             instance.setLabel(lang.getTranslation("transcripts.success.visit"))
         })
     )
 
     //TRANSCRIPT ERROR RETRY
-    buttons.add(new api.ODButton("openticket:transcript-error-retry"))
+    buttons.add(new api.ODButton("opendiscord:transcript-error-retry"))
-    buttons.get("openticket:transcript-error-retry").workers.add(
+    buttons.get("opendiscord:transcript-error-retry").workers.add(
-        new api.ODWorker("openticket:transcript-error-retry",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:transcript-error-retry",0,async (instance,params,source) => {
             instance.setMode("button")
             instance.setCustomId("od:transcript-error-retry_"+source)
             instance.setColor("gray")
@@ -324,9 +324,9 @@ const transcriptButtons = () => {
     )
 
     //TRANSCRIPT ERROR CONTINUE
-    buttons.add(new api.ODButton("openticket:transcript-error-continue"))
+    buttons.add(new api.ODButton("opendiscord:transcript-error-continue"))
-    buttons.get("openticket:transcript-error-continue").workers.add(
+    buttons.get("opendiscord:transcript-error-continue").workers.add(
-        new api.ODWorker("openticket:transcript-error-continue",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:transcript-error-continue",0,async (instance,params,source) => {
             instance.setMode("button")
             instance.setCustomId("od:transcript-error-continue_"+source)
             instance.setColor("red")
@@ -338,9 +338,9 @@ const transcriptButtons = () => {
 
 const clearButtons = () => {
     //CLEAR CONTINUE
-    buttons.add(new api.ODButton("openticket:clear-continue"))
+    buttons.add(new api.ODButton("opendiscord:clear-continue"))
-    buttons.get("openticket:clear-continue").workers.add(
+    buttons.get("opendiscord:clear-continue").workers.add(
-        new api.ODWorker("openticket:clear-continue",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:clear-continue",0,async (instance,params,source) => {
             instance.setMode("button")
             instance.setCustomId("od:clear-continue_"+source+"_"+params.filter)
             instance.setColor("red")

src/builders/dropdowns.ts

@@ -1,10 +1,10 @@
 ///////////////////////////////////////
 //DROPDOWN BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const dropdowns = openticket.builders.dropdowns
+const dropdowns = opendiscord.builders.dropdowns
 
 export const registerAllDropdowns = async () => {
     panelDropdowns()
@@ -12,19 +12,22 @@ export const registerAllDropdowns = async () => {
 
 const panelDropdowns = () => {
     //TICKET OPTION
-    dropdowns.add(new api.ODDropdown("openticket:panel-dropdown-tickets"))
+    dropdowns.add(new api.ODDropdown("opendiscord:panel-dropdown-tickets"))
-    dropdowns.get("openticket:panel-dropdown-tickets").workers.add(
+    dropdowns.get("opendiscord:panel-dropdown-tickets").workers.add(
-        new api.ODWorker("openticket:panel-dropdown-tickets",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:panel-dropdown-tickets",0,async (instance,params) => {
             const {panel,options} = params
             
-
             const parsedOptions: api.ODDropdownData["options"] = options.map((option) => {
-                const desc = option.get("openticket:description").value.substring(0,100)
+                const label = option.get("opendiscord:button-label").value.substring(0,100)
+                const desc = option.get("opendiscord:description").value.substring(0,100)
+                const emoji = option.get("opendiscord:button-emoji").value
+                
                 return {
-                    label:option.get("openticket:button-label").value.substring(0,100),
+                    label:(label.length > 0) ? label : "<no-label-provided>",
                     value:"od:ticket-option_"+panel.id.value+"_"+option.id.value,
-                    emoji:option.get("openticket:button-emoji").value,
+                    emoji:(emoji.length > 0) ? emoji : undefined,
-                    description:(desc.length > 0) ? desc : undefined
+                    description:(desc.length > 0) ? desc : undefined,
+                    default:false
                 }
             })
 
@@ -32,7 +35,7 @@ const panelDropdowns = () => {
             instance.setType("string")
             instance.setMaxValues(1)
             instance.setMinValues(0)
-            instance.setPlaceholder(panel.get("openticket:dropdown-placeholder").value)
+            instance.setPlaceholder(panel.get("opendiscord:dropdown-placeholder").value)
             instance.setOptions(parsedOptions)
         })
     )

src/builders/embeds.ts

@@ -1,13 +1,13 @@
 ///////////////////////////////////////
 //EMBED BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 import nodepath from "path"
 
-const embeds = openticket.builders.embeds
+const embeds = opendiscord.builders.embeds
-const lang = openticket.languages
+const lang = opendiscord.languages
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerAllEmbeds = async () => {
     errorEmbeds()
@@ -34,9 +34,9 @@ const getMethodFromSource = (source:"slash"|"text"|"button"|"dropdown"|"modal"|"
 
 const errorEmbeds = () => {
     //ERROR
-    embeds.add(new api.ODEmbed("openticket:error"))
+    embeds.add(new api.ODEmbed("opendiscord:error"))
-    embeds.get("openticket:error").workers.add(
+    embeds.get("opendiscord:error").workers.add(
-        new api.ODWorker("openticket:error",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error",0,async (instance,params,source) => {
             const {user,error,layout} = params
             
             const method = getMethodFromSource(source)
@@ -51,9 +51,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR OPTION MISSING
-    embeds.add(new api.ODEmbed("openticket:error-option-missing"))
+    embeds.add(new api.ODEmbed("opendiscord:error-option-missing"))
-    embeds.get("openticket:error-option-missing").workers.add(
+    embeds.get("opendiscord:error-option-missing").workers.add(
-        new api.ODWorker("openticket:error-option-missing",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:error-option-missing",0,async (instance,params) => {
             const {user,error} = params
             
             const options = error.command.builder.options ?? []
@@ -83,9 +83,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR OPTION INVALID
-    embeds.add(new api.ODEmbed("openticket:error-option-invalid"))
+    embeds.add(new api.ODEmbed("opendiscord:error-option-invalid"))
-    embeds.get("openticket:error-option-invalid").workers.add(
+    embeds.get("opendiscord:error-option-invalid").workers.add(
-        new api.ODWorker("openticket:error-option-invalid",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:error-option-invalid",0,async (instance,params) => {
             const {user,error} = params
             
             const options = error.command.builder.options ?? []
@@ -138,9 +138,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR UNKNOWN COMMAND
-    embeds.add(new api.ODEmbed("openticket:error-unknown-command"))
+    embeds.add(new api.ODEmbed("opendiscord:error-unknown-command"))
-    embeds.get("openticket:error-unknown-command").workers.add(
+    embeds.get("opendiscord:error-unknown-command").workers.add(
-        new api.ODWorker("openticket:error-unknown-command",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:error-unknown-command",0,async (instance,params) => {
             const {user} = params
             
             instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -151,9 +151,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR NO PERMISSIONS
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions"))
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions"))
-    embeds.get("openticket:error-no-permissions").workers.add(
+    embeds.get("opendiscord:error-no-permissions").workers.add(
-        new api.ODWorker("openticket:error-no-permissions",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-no-permissions",0,async (instance,params,source) => {
             const {user,permissions} = params
             
             const method = getMethodFromSource(source)
@@ -177,9 +177,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR NO PERMISSIONS COOLDOWN
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions-cooldown"))
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions-cooldown"))
-    embeds.get("openticket:error-no-permissions-cooldown").workers.add(
+    embeds.get("opendiscord:error-no-permissions-cooldown").workers.add(
-        new api.ODWorker("openticket:error-no-permissions-cooldown",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-no-permissions-cooldown",0,async (instance,params,source) => {
             const {user} = params
             
             const method = getMethodFromSource(source)
@@ -193,9 +193,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR NO PERMISSIONS BLACKLISTED
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions-blacklisted"))
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions-blacklisted"))
-    embeds.get("openticket:error-no-permissions-blacklisted").workers.add(
+    embeds.get("opendiscord:error-no-permissions-blacklisted").workers.add(
-        new api.ODWorker("openticket:error-no-permissions-blacklisted",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-no-permissions-blacklisted",0,async (instance,params,source) => {
             const {user} = params
             
             const method = getMethodFromSource(source)
@@ -208,9 +208,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR NO PERMISSIONS LIMITS
-    embeds.add(new api.ODEmbed("openticket:error-no-permissions-limits"))
+    embeds.add(new api.ODEmbed("opendiscord:error-no-permissions-limits"))
-    embeds.get("openticket:error-no-permissions-limits").workers.add(
+    embeds.get("opendiscord:error-no-permissions-limits").workers.add(
-        new api.ODWorker("openticket:error-no-permissions-limits",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-no-permissions-limits",0,async (instance,params,source) => {
             const {user,limit} = params
             
             instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -224,9 +224,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR RESPONDER TIMEOUT
-    embeds.add(new api.ODEmbed("openticket:error-responder-timeout"))
+    embeds.add(new api.ODEmbed("opendiscord:error-responder-timeout"))
-    embeds.get("openticket:error-responder-timeout").workers.add(
+    embeds.get("opendiscord:error-responder-timeout").workers.add(
-        new api.ODWorker("openticket:error-responder-timeout",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-responder-timeout",0,async (instance,params,source) => {
             const {user} = params
             
             const method = getMethodFromSource(source)
@@ -241,9 +241,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR TICKET UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:error-ticket-unknown"))
+    embeds.add(new api.ODEmbed("opendiscord:error-ticket-unknown"))
-    embeds.get("openticket:error-ticket-unknown").workers.add(
+    embeds.get("opendiscord:error-ticket-unknown").workers.add(
-        new api.ODWorker("openticket:error-ticket-unknown",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-ticket-unknown",0,async (instance,params,source) => {
             const {user} = params
 
             instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -255,9 +255,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR TICKET DEPRECATED
-    embeds.add(new api.ODEmbed("openticket:error-ticket-deprecated"))
+    embeds.add(new api.ODEmbed("opendiscord:error-ticket-deprecated"))
-    embeds.get("openticket:error-ticket-deprecated").workers.add(
+    embeds.get("opendiscord:error-ticket-deprecated").workers.add(
-        new api.ODWorker("openticket:error-ticket-deprecated",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-ticket-deprecated",0,async (instance,params,source) => {
             const {user} = params
 
             instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -269,14 +269,14 @@ const errorEmbeds = () => {
     )
 
     //ERROR OPTION UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:error-option-unknown"))
+    embeds.add(new api.ODEmbed("opendiscord:error-option-unknown"))
-    embeds.get("openticket:error-option-unknown").workers.add(
+    embeds.get("opendiscord:error-option-unknown").workers.add(
-        new api.ODWorker("openticket:error-option-unknown",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-option-unknown",0,async (instance,params,source) => {
             const {user} = params
 
-            const renderedTicketOptions = openticket.options.getAll().map((option) => {
+            const renderedTicketOptions = opendiscord.options.getAll().map((option) => {
-                if (option instanceof api.ODTicketOption && option.exists("openticket:name")){
+                if (option instanceof api.ODTicketOption && option.exists("opendiscord:name")){
-                    return "- **"+option.get("openticket:name").value+":** `"+option.id.value+"`"
+                    return "- **"+option.get("opendiscord:name").value+":** `"+option.id.value+"`"
                 }else return "- `"+option.id.value+"`"
             }).join("\n")
 
@@ -289,14 +289,14 @@ const errorEmbeds = () => {
     )
 
     //ERROR PANEL UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:error-panel-unknown"))
+    embeds.add(new api.ODEmbed("opendiscord:error-panel-unknown"))
-    embeds.get("openticket:error-panel-unknown").workers.add(
+    embeds.get("opendiscord:error-panel-unknown").workers.add(
-        new api.ODWorker("openticket:error-panel-unknown",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-panel-unknown",0,async (instance,params,source) => {
             const {user} = params
 
-            const renderedPanels = openticket.panels.getAll().map((panel) => {
+            const renderedPanels = opendiscord.panels.getAll().map((panel) => {
-                if (panel.exists("openticket:name")){
+                if (panel.exists("opendiscord:name")){
-                    return "- **"+panel.get("openticket:name").value+":** `"+panel.id.value+"`"
+                    return "- **"+panel.get("opendiscord:name").value+":** `"+panel.id.value+"`"
                 }else return "- `"+panel.id.value+"`"
             }).join("\n")
 
@@ -309,9 +309,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR NOT IN GUILD
-    embeds.add(new api.ODEmbed("openticket:error-not-in-guild"))
+    embeds.add(new api.ODEmbed("opendiscord:error-not-in-guild"))
-    embeds.get("openticket:error-not-in-guild").workers.add(
+    embeds.get("opendiscord:error-not-in-guild").workers.add(
-        new api.ODWorker("openticket:error-not-in-guild",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-not-in-guild",0,async (instance,params,source) => {
             const {user} = params
 
             const method = getMethodFromSource(source)
@@ -324,9 +324,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR CHANNEL RENAME
-    embeds.add(new api.ODEmbed("openticket:error-channel-rename"))
+    embeds.add(new api.ODEmbed("opendiscord:error-channel-rename"))
-    embeds.get("openticket:error-channel-rename").workers.add(
+    embeds.get("opendiscord:error-channel-rename").workers.add(
-        new api.ODWorker("openticket:error-channel-rename",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-channel-rename",0,async (instance,params,source) => {
             const {channel,user,originalName,newName} = params
             
             const method = (source == "ticket-move" || source == "ticket-pin" || source == "ticket-rename" || source == "ticket-unpin") ? source : getMethodFromSource(source)
@@ -344,9 +344,9 @@ const errorEmbeds = () => {
     )
 
     //ERROR TICKET BUSY
-    embeds.add(new api.ODEmbed("openticket:error-ticket-busy"))
+    embeds.add(new api.ODEmbed("opendiscord:error-ticket-busy"))
-    embeds.get("openticket:error-ticket-busy").workers.add(
+    embeds.get("opendiscord:error-ticket-busy").workers.add(
-        new api.ODWorker("openticket:error-ticket-busy",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:error-ticket-busy",0,async (instance,params,source) => {
             const {user} = params
             
             const method = getMethodFromSource(source)
@@ -362,17 +362,17 @@ const errorEmbeds = () => {
 
 const helpMenuEmbeds = () => {
     //HELP MENU
-    embeds.add(new api.ODEmbed("openticket:help-menu"))
+    embeds.add(new api.ODEmbed("opendiscord:help-menu"))
-    embeds.get("openticket:help-menu").workers.add(
+    embeds.get("opendiscord:help-menu").workers.add(
-        new api.ODWorker("openticket:help-menu",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:help-menu",0,async (instance,params) => {
             const {mode,page} = params
             
             instance.setColor(generalConfig.data.mainColor)
             instance.setTitle(utilities.emojiTitle("ℹ️",lang.getTranslation("actions.titles.help")))
             instance.setDescription(lang.getTranslation("actions.descriptions.helpExplanation"))
-            instance.setThumbnail(openticket.client.client.user.displayAvatarURL())
+            instance.setThumbnail(opendiscord.client.client.user.displayAvatarURL())
             
-            const data = await openticket.helpmenu.render(mode)
+            const data = await opendiscord.helpmenu.render(mode)
             const currentData = data[page] ?? []
             instance.setFields(currentData)
         })
@@ -381,12 +381,12 @@ const helpMenuEmbeds = () => {
 
 const statsEmbeds = () => {
     //STATS GLOBAL
-    embeds.add(new api.ODEmbed("openticket:stats-global"))
+    embeds.add(new api.ODEmbed("opendiscord:stats-global"))
-    embeds.get("openticket:stats-global").workers.add(
+    embeds.get("opendiscord:stats-global").workers.add(
-        new api.ODWorker("openticket:stats-global",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:stats-global",0,async (instance,params) => {
             const {guild,channel,user} = params
             
-            const scope = openticket.stats.get("openticket:global")
+            const scope = opendiscord.stats.get("opendiscord:global")
             if (!scope) return
             const data = await scope.render("GLOBAL",guild,channel,user)
             
@@ -394,9 +394,9 @@ const statsEmbeds = () => {
             instance.setTitle(scope.name)
             instance.setDescription(data)
             
-            if (openticket.permissions.hasPermissions("owner",await openticket.permissions.getPermissions(user,channel,guild))){
+            if (opendiscord.permissions.hasPermissions("owner",await opendiscord.permissions.getPermissions(user,channel,guild))){
                 //show system data when owner or developer
-                const systemScope = openticket.stats.get("openticket:system")
+                const systemScope = opendiscord.stats.get("opendiscord:system")
                 if (!systemScope) return
                 const systemData = await systemScope.render("GLOBAL",guild,channel,user)
                 instance.addFields({name:systemScope.name,value:systemData,inline:false})
@@ -405,13 +405,13 @@ const statsEmbeds = () => {
     )
 
     //STATS TICKET
-    embeds.add(new api.ODEmbed("openticket:stats-ticket"))
+    embeds.add(new api.ODEmbed("opendiscord:stats-ticket"))
-    embeds.get("openticket:stats-ticket").workers.add(
+    embeds.get("opendiscord:stats-ticket").workers.add(
-        new api.ODWorker("openticket:stats-ticket",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:stats-ticket",0,async (instance,params) => {
             const {guild,channel,user,scopeData} = params
             
-            const scope = openticket.stats.get("openticket:ticket")
+            const scope = opendiscord.stats.get("opendiscord:ticket")
-            const participantsScope = openticket.stats.get("openticket:participants")
+            const participantsScope = opendiscord.stats.get("opendiscord:participants")
             if (!scope || !participantsScope) return
             const data = await scope.render(scopeData.id.value,guild,channel,user)
             const participantsData = await participantsScope.render(scopeData.id.value,guild,channel,user)
@@ -424,12 +424,12 @@ const statsEmbeds = () => {
     )
 
     //STATS USER
-    embeds.add(new api.ODEmbed("openticket:stats-user"))
+    embeds.add(new api.ODEmbed("opendiscord:stats-user"))
-    embeds.get("openticket:stats-user").workers.add([
+    embeds.get("opendiscord:stats-user").workers.add([
-        new api.ODWorker("openticket:stats-user",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:stats-user",0,async (instance,params) => {
             const {guild,channel,user,scopeData} = params
             
-            const scope = openticket.stats.get("openticket:user")
+            const scope = opendiscord.stats.get("opendiscord:user")
             if (!scope) return
             const data = await scope.render(scopeData.id,guild,channel,user)
             
@@ -438,9 +438,9 @@ const statsEmbeds = () => {
             instance.setDescription(data)
             instance.setThumbnail(scopeData.displayAvatarURL())
         }),
-        new api.ODWorker("openticket:easter-egg",-1,async (instance,params) => {
+        new api.ODWorker("opendiscord:easter-egg",-1,async (instance,params) => {
-            if (!openticket.flags.exists("openticket:no-easter")) return
+            if (!opendiscord.flags.exists("opendiscord:no-easter")) return
-            const easterFlag = openticket.flags.get("openticket:no-easter")
+            const easterFlag = opendiscord.flags.get("opendiscord:no-easter")
             if (!easterFlag.value){
                 //🥚 add easter egg 🥚
                 const {user} = params
@@ -449,14 +449,14 @@ const statsEmbeds = () => {
                 }else if (utilities.easterEggs.translators.includes(user.id)){
                     instance.setFooter("💬 Open Ticket Translator")
                 }
-            }            
+            }
         })
     ])
 
     //STATS RESET
-    embeds.add(new api.ODEmbed("openticket:stats-reset"))
+    embeds.add(new api.ODEmbed("opendiscord:stats-reset"))
-    embeds.get("openticket:stats-reset").workers.add(
+    embeds.get("opendiscord:stats-reset").workers.add(
-        new api.ODWorker("openticket:stats-reset",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:stats-reset",0,async (instance,params) => {
             const {user,reason} = params
             
             instance.setColor(generalConfig.data.mainColor)
@@ -468,9 +468,9 @@ const statsEmbeds = () => {
     )
 
     //STATS TICKET UNKNOWN
-    embeds.add(new api.ODEmbed("openticket:stats-ticket-unknown"))
+    embeds.add(new api.ODEmbed("opendiscord:stats-ticket-unknown"))
-    embeds.get("openticket:stats-ticket-unknown").workers.add(
+    embeds.get("opendiscord:stats-ticket-unknown").workers.add(
-        new api.ODWorker("openticket:stats-ticket-unknown",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:stats-ticket-unknown",0,async (instance,params) => {
             const {user,id} = params
             
             instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -483,14 +483,14 @@ const statsEmbeds = () => {
 
 const panelEmbeds = () => {
     //PANEL
-    embeds.add(new api.ODEmbed("openticket:panel"))
+    embeds.add(new api.ODEmbed("opendiscord:panel"))
-    embeds.get("openticket:panel").workers.add(
+    embeds.get("opendiscord:panel").workers.add(
-        new api.ODWorker("openticket:panel",0,async (instance,params) => {
+        new api.ODWorker("opendiscord:panel",0,async (instance,params) => {
             const {panel} = params
-            if (!panel.exists("openticket:embed")) return
+            if (!panel.exists("opendiscord:embed")) return
-            const embedOptions = panel.get("openticket:embed").value
+            const embedOptions = panel.get("opendiscord:embed").value
             
-            instance.setColor(embedOptions.customColor ? (embedOptions.customColor as discord.ColorResolvable) : generalConfig.data.mainColor)
+            instance.setColor(embedOptions.customColor ? embedOptions.customColor : generalConfig.data.mainColor)
             instance.setTitle(embedOptions.title)
             if (embedOptions.thumbnail) instance.setThumbnail(embedOptions.thumbnail)
             if (embedOptions.image) instance.setImage(embedOptions.image)
@@ -498,7 +498,7 @@ const panelEmbeds = () => {
             if (embedOptions.footer) instance.setFooter(embedOptions.footer)
             if (embedOptions.timestamp) instance.setTimestamp(new Date())
             
-            if (panel.get("openticket:describe-options-in-embed-description").value){
+            if (panel.get("opendiscord:describe-options-in-embed-description").value){
                 //describe options in description
                 const text = (await import("../data/openticket/panelLoader.js")).describePanelOptions("text",panel)
                 instance.setDescription(embedOptions.description+"\n\n"+text)
@@ -506,11 +506,11 @@ const panelEmbeds = () => {
                 instance.setDescription(embedOptions.description)
             }
 
-            if (panel.get("openticket:enable-max-tickets-warning-embed").value && generalConfig.data.system.limits.enabled){
+            if (panel.get("opendiscord:enable-max-tickets-warning-embed").value && generalConfig.data.system.limits.enabled){
                 instance.setDescription(instance.data.description+"\n\n*"+lang.getTranslationWithParams("actions.descriptions.ticketMessageLimit",[generalConfig.data.system.limits.userMaximum.toString()])+"*")
             }
 
-            if (panel.get("openticket:describe-options-in-embed-fields").value){
+            if (panel.get("opendiscord:describe-options-in-embed-fields").value){
                 //describe options in fields
                 const fields = (await import("../data/openticket/panelLoader.js")).describePanelOptions("fields",panel)
                 instance.setFields(fields)
@@ -523,9 +523,9 @@ const panelEmbeds = () => {
 
 const ticketEmbeds = () => {
     //TICKET CREATED
-    embeds.add(new api.ODEmbed("openticket:ticket-created"))
+    embeds.add(new api.ODEmbed("opendiscord:ticket-created"))
-    embeds.get("openticket:ticket-created").workers.add(
+    embeds.get("opendiscord:ticket-created").workers.add(
-        new api.ODWorker("openticket:ticket-created",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:ticket-created",0,async (instance,params,source) => {
             const {user} = params
 
             instance.setColor(generalConfig.data.mainColor)
@@ -537,11 +537,11 @@ const ticketEmbeds = () => {
     )
 
     //TICKET CREATED DM
-    embeds.add(new api.ODEmbed("openticket:ticket-created-dm"))
+    embeds.add(new api.ODEmbed("opendiscord:ticket-created-dm"))
-    embeds.get("openticket:ticket-created-dm").workers.add(
+    embeds.get("opendiscord:ticket-created-dm").workers.add(
-        new api.ODWorker("openticket:ticket-created-dm",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:ticket-created-dm",0,async (instance,params,source) => {
             const {user,ticket} = params
-            const embedOptions = ticket.option.get("openticket:dm-message-embed").value
+            const embedOptions = ticket.option.get("opendiscord:dm-message-embed").value
             
             instance.setColor(embedOptions.customColor ? (embedOptions.customColor as discord.ColorResolvable) : generalConfig.data.mainColor)
             instance.setTitle(embedOptions.title)
@@ -551,19 +551,19 @@ const ticketEmbeds = () => {
             if (embedOptions.description) instance.setDescription(embedOptions.description)
             if (embedOptions.fields) instance.setFields(embedOptions.fields)
             
-            if (ticket.get("openticket:closed").value && ticket.get("openticket:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.option.get("openticket:autodelete-days").value.toString()]))
+            if (ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.option.get("opendiscord:autodelete-days").value.toString()]))
-            else if (!ticket.get("openticket:closed").value && ticket.get("openticket:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.option.get("openticket:autoclose-hours").value.toString()]))       
+            else if (!ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.option.get("opendiscord:autoclose-hours").value.toString()]))       
         })
     )
 
     //TICKET CREATED LOGS
-    embeds.add(new api.ODEmbed("openticket:ticket-created-logs"))
+    embeds.add(new api.ODEmbed("opendiscord:ticket-created-logs"))
-    embeds.get("openticket:ticket-created-logs").workers.add(
+    embeds.get("opendiscord:ticket-created-logs").workers.add(
-        new api.ODWorker("openticket:ticket-created-logs",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:ticket-created-logs",0,async (instance,params,source) => {
             const {user,ticket} = params
             
             const method = (source == "panel-button" || source == "panel-dropdown") ? lang.getTranslation("params.uppercase.panel") : (source == "slash" || source == "text") ? lang.getTranslation("params.uppercase.command") : lang.getTranslation("params.uppercase.system")
-            const blacklisted = openticket.blacklist.exists(user.id) ? lang.getTranslation("params.uppercase.true") : lang.getTranslation("params.uppercase.false")
+            const blacklisted = opendiscord.blacklist.exists(user.id) ? lang.getTranslation("params.uppercase.true") : lang.getTranslation("params.uppercase.false")
 
             instance.setColor(generalConfig.data.mainColor)
             instance.setTitle(utilities.emojiTitle("🎫",lang.getTranslation("actions.titles.created")))
@@ -572,7 +572,7 @@ const ticketEmbeds = () => {
             instance.setTimestamp(new Date())
             instance.setDescription(lang.getTranslationWithParams("actions.logs.createLog",[discord.userMention(user.id)]))
             instance.addFields(
-                {name:lang.getTranslation("params.uppercase.type")+":",value:"```"+ticket.option.get("openticket:name").value+"```",inline:false},
+                {name:lang.getTranslation("params.uppercase.type")+":",value:"```"+ticket.option.get("opendiscord:name").value+"```",inline:false},
                 {name:lang.getTranslation("params.uppercase.method")+":",value:"```"+method+"```",inline:true},
                 {name:lang.getTranslation("params.uppercase.blacklisted")+":",value:"```"+blacklisted+"```", inline:true}
             )
@@ -580,21 +580,21 @@ const ticketEmbeds = () => {
     )
 
     //TICKET MESSAGE
-    embeds.add(new api.ODEmbed("openticket:ticket-message"))
+    embeds.add(new api.ODEmbed("opendiscord:ticket-message"))
-    embeds.get("openticket:ticket-message").workers.add(
+    embeds.get("opendiscord:ticket-message").workers.add(
-        new api.ODWorker("openticket:ticket-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:ticket-message",0,async (instance,params,source) => {
             const {user,ticket} = params
-            const embedOptions = ticket.option.get("openticket:ticket-message-embed").value
+            const embedOptions = ticket.option.get("opendiscord:ticket-message-embed").value
             
-            instance.setColor(embedOptions.customColor ? (embedOptions.customColor as discord.ColorResolvable) : generalConfig.data.mainColor)
+            instance.setColor(embedOptions.customColor ? embedOptions.customColor : generalConfig.data.mainColor)
             if (embedOptions.title) instance.setTitle(embedOptions.title)
             if (embedOptions.thumbnail) instance.setThumbnail(embedOptions.thumbnail)
             if (embedOptions.image) instance.setImage(embedOptions.image)
             if (embedOptions.timestamp) instance.setTimestamp(new Date())
             if (embedOptions.description) instance.setDescription(embedOptions.description)
             
-            if (ticket.option.get("openticket:questions").value.length > 0){
+            if (ticket.option.get("opendiscord:questions").value.length > 0){
-                const answers = ticket.get("openticket:answers").value
+                const answers = ticket.get("opendiscord:answers").value
                 answers.forEach((answer) => {
                     if (!answer.value || answer.value.length == 0) return
                     if (generalConfig.data.system.questionFieldsInCodeBlock) instance.addFields({name:answer.name,value:"```"+answer.value+"```",inline:false})
@@ -604,11 +604,11 @@ const ticketEmbeds = () => {
                 instance.setFields(embedOptions.fields)
             }
 
-            if (ticket.get("openticket:closed").value && ticket.get("openticket:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.option.get("openticket:autodelete-days").value.toString()]))
+            if (ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autodelete-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutodelete",[ticket.get("opendiscord:autodelete-days").value.toString()]))
-            else if (!ticket.get("openticket:closed").value && ticket.get("openticket:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.option.get("openticket:autoclose-hours").value.toString()]))
+            else if (!ticket.get("opendiscord:closed").value && ticket.get("opendiscord:autoclose-enabled").value) instance.setFooter("⏱️ "+lang.getTranslationWithParams("actions.descriptions.ticketMessageAutoclose",[ticket.get("opendiscord:autoclose-hours").value.toString()]))
             
-            if (ticket.get("openticket:claimed").value){
+            if (ticket.get("opendiscord:claimed").value){
-                const claimUser = await openticket.tickets.getTicketUser(ticket,"claimer")
+                const claimUser = await opendiscord.tickets.getTicketUser(ticket,"claimer")
                 if (!claimUser) return
                 instance.setAuthor(lang.getTranslationWithParams("params.uppercase.claimedBy",[claimUser.displayName]),claimUser.displayAvatarURL())
             }
@@ -616,9 +616,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET CLOSED
-    embeds.add(new api.ODEmbed("openticket:close-message"))
+    embeds.add(new api.ODEmbed("opendiscord:close-message"))
-    embeds.get("openticket:close-message").workers.add(
+    embeds.get("opendiscord:close-message").workers.add(
-        new api.ODWorker("openticket:close-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:close-message",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -630,9 +630,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET REOPENED
-    embeds.add(new api.ODEmbed("openticket:reopen-message"))
+    embeds.add(new api.ODEmbed("opendiscord:reopen-message"))
-    embeds.get("openticket:reopen-message").workers.add(
+    embeds.get("opendiscord:reopen-message").workers.add(
-        new api.ODWorker("openticket:reopen-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:reopen-message",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -644,9 +644,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET DELETED
-    embeds.add(new api.ODEmbed("openticket:delete-message"))
+    embeds.add(new api.ODEmbed("opendiscord:delete-message"))
-    embeds.get("openticket:delete-message").workers.add(
+    embeds.get("opendiscord:delete-message").workers.add(
-        new api.ODWorker("openticket:delete-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:delete-message",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -658,9 +658,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET CLAIMED
-    embeds.add(new api.ODEmbed("openticket:claim-message"))
+    embeds.add(new api.ODEmbed("opendiscord:claim-message"))
-    embeds.get("openticket:claim-message").workers.add(
+    embeds.get("opendiscord:claim-message").workers.add(
-        new api.ODWorker("openticket:claim-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:claim-message",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -672,9 +672,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET UNCLAIMED
-    embeds.add(new api.ODEmbed("openticket:unclaim-message"))
+    embeds.add(new api.ODEmbed("opendiscord:unclaim-message"))
-    embeds.get("openticket:unclaim-message").workers.add(
+    embeds.get("opendiscord:unclaim-message").workers.add(
-        new api.ODWorker("openticket:unclaim-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:unclaim-message",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -686,9 +686,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET PINNED
-    embeds.add(new api.ODEmbed("openticket:pin-message"))
+    embeds.add(new api.ODEmbed("opendiscord:pin-message"))
-    embeds.get("openticket:pin-message").workers.add(
+    embeds.get("opendiscord:pin-message").workers.add(
-        new api.ODWorker("openticket:pin-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:pin-message",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -700,9 +700,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET UNPINNED
-    embeds.add(new api.ODEmbed("openticket:unpin-message"))
+    embeds.add(new api.ODEmbed("opendiscord:unpin-message"))
-    embeds.get("openticket:unpin-message").workers.add(
+    embeds.get("opendiscord:unpin-message").workers.add(
-        new api.ODWorker("openticket:unpin-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:unpin-message",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -714,9 +714,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET RENAMED
-    embeds.add(new api.ODEmbed("openticket:rename-message"))
+    embeds.add(new api.ODEmbed("opendiscord:rename-message"))
-    embeds.get("openticket:rename-message").workers.add(
+    embeds.get("opendiscord:rename-message").workers.add(
-        new api.ODWorker("openticket:rename-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:rename-message",0,async (instance,params,source) => {
             const {user,ticket,reason,data} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -728,23 +728,23 @@ const ticketEmbeds = () => {
     )
 
     //TICKET MOVED
-    embeds.add(new api.ODEmbed("openticket:move-message"))
+    embeds.add(new api.ODEmbed("opendiscord:move-message"))
-    embeds.get("openticket:move-message").workers.add(
+    embeds.get("opendiscord:move-message").workers.add(
-        new api.ODWorker("openticket:move-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:move-message",0,async (instance,params,source) => {
             const {user,ticket,reason,data} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
             instance.setColor(generalConfig.data.mainColor)
             instance.setTitle(utilities.emojiTitle("🔀",lang.getTranslation("actions.titles.move")))
-            instance.setDescription(lang.getTranslationWithParams("actions.descriptions.move",["`"+data.get("openticket:name").value+"`"]))
+            instance.setDescription(lang.getTranslationWithParams("actions.descriptions.move",["`"+data.get("opendiscord:name").value+"`"]))
             if (reason) instance.addFields({name:lang.getTranslation("params.uppercase.reason")+":",value:"```"+reason+"```"})
         })
     )
 
     //TICKET USER ADDED
-    embeds.add(new api.ODEmbed("openticket:add-message"))
+    embeds.add(new api.ODEmbed("opendiscord:add-message"))
-    embeds.get("openticket:add-message").workers.add(
+    embeds.get("opendiscord:add-message").workers.add(
-        new api.ODWorker("openticket:add-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:add-message",0,async (instance,params,source) => {
             const {user,ticket,reason,data} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -756,9 +756,9 @@ const ticketEmbeds = () => {
     )
 
     //TICKET USER REMOVED
-    embeds.add(new api.ODEmbed("openticket:remove-message"))
+    embeds.add(new api.ODEmbed("opendiscord:remove-message"))
-    embeds.get("openticket:remove-message").workers.add(
+    embeds.get("opendiscord:remove-message").workers.add(
-        new api.ODWorker("openticket:remove-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:remove-message",0,async (instance,params,source) => {
             const {user,ticket,reason,data} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -770,11 +770,11 @@ const ticketEmbeds = () => {
     )
     
     //TICKET ACTION DM
-    embeds.add(new api.ODEmbed("openticket:ticket-action-dm"))
+    embeds.add(new api.ODEmbed("opendiscord:ticket-action-dm"))
-    embeds.get("openticket:ticket-action-dm").workers.add(
+    embeds.get("opendiscord:ticket-action-dm").workers.add(
-        new api.ODWorker("openticket:ticket-action-dm",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:ticket-action-dm",0,async (instance,params,source) => {
             const {user,mode,ticket,reason,additionalData} = params
-            const channel = await openticket.tickets.getTicketChannel(ticket)
+            const channel = await opendiscord.tickets.getTicketChannel(ticket)
             
             instance.setColor(generalConfig.data.mainColor)
             instance.setTimestamp(new Date())
@@ -807,7 +807,7 @@ const ticketEmbeds = () => {
                 instance.setDescription(lang.getTranslationWithParams("actions.logs.renameDm",["`#"+(typeof additionalData == "string" ? additionalData : "<unknown>")+"`"]))
             }else if (mode == "move"){
                 instance.setTitle(utilities.emojiTitle("🔀",lang.getTranslation("actions.titles.move")))
-                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveDm",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("openticket:name").value : "<unknown>")+"`"]))
+                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveDm",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("opendiscord:name").value : "<unknown>")+"`"]))
             }else if (mode == "add"){
                 instance.setTitle(utilities.emojiTitle("👤",lang.getTranslation("actions.titles.add")))
                 instance.setDescription(lang.getTranslationWithParams("actions.logs.addDm",[(additionalData instanceof discord.User ? discord.userMention(additionalData.id) : "<unknown>")]))
@@ -819,11 +819,11 @@ const ticketEmbeds = () => {
     )
 
     //TICKET ACTION LOGS
-    embeds.add(new api.ODEmbed("openticket:ticket-action-logs"))
+    embeds.add(new api.ODEmbed("opendiscord:ticket-action-logs"))
-    embeds.get("openticket:ticket-action-logs").workers.add(
+    embeds.get("opendiscord:ticket-action-logs").workers.add(
-        new api.ODWorker("openticket:ticket-action-logs",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:ticket-action-logs",0,async (instance,params,source) => {
             const {user,mode,ticket,reason,additionalData} = params
-            const channel = await openticket.tickets.getTicketChannel(ticket)
+            const channel = await opendiscord.tickets.getTicketChannel(ticket)
 
             instance.setColor(generalConfig.data.mainColor)
             instance.setThumbnail(user.displayAvatarURL())
@@ -832,7 +832,7 @@ const ticketEmbeds = () => {
             instance.addFields(
                 {name:lang.getTranslation("params.uppercase.ticket")+":",value:"```#"+(channel ? channel.name : "<unknown>")+"```",inline:false},
                 //TODO TRANSLATION!!!
-                {name:"Option"+":",value:"```"+(ticket.option.get("openticket:name").value)+"```",inline:false},
+                {name:"Option"+":",value:"```"+(ticket.option.get("opendiscord:name").value)+"```",inline:false},
             )
             if (reason) instance.addFields({name:lang.getTranslation("params.uppercase.reason")+":",value:"```"+reason+"```",inline:false})
 
@@ -862,7 +862,7 @@ const ticketEmbeds = () => {
                 instance.setDescription(lang.getTranslationWithParams("actions.logs.renameLog",["`#"+(typeof additionalData == "string" ? additionalData : "<unknown>")+"`",discord.userMention(user.id)]))
             }else if (mode == "move"){
                 instance.setTitle(utilities.emojiTitle("🔀",lang.getTranslation("actions.titles.move")))
-                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveLog",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("openticket:name").value : "<unknown>")+"`",discord.userMention(user.id)]))
+                instance.setDescription(lang.getTranslationWithParams("actions.logs.moveLog",["`"+(additionalData instanceof api.ODTicketOption ? additionalData.get("opendiscord:name").value : "<unknown>")+"`",discord.userMention(user.id)]))
             }else if (mode == "add"){
                 instance.setTitle(utilities.emojiTitle("👤",lang.getTranslation("actions.titles.add")))
                 instance.setDescription(lang.getTranslationWithParams("actions.logs.addLog",[(additionalData instanceof discord.User ? discord.userMention(additionalData.id) : "<unknown>"),discord.userMention(user.id)]))
@@ -876,13 +876,13 @@ const ticketEmbeds = () => {
 
 const blacklistEmbeds = () => {
     //BLACKLIST VIEW
-    embeds.add(new api.ODEmbed("openticket:blacklist-view"))
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-view"))
-    embeds.get("openticket:blacklist-view").workers.add(
+    embeds.get("opendiscord:blacklist-view").workers.add(
-        new api.ODWorker("openticket:blacklist-view",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:blacklist-view",0,async (instance,params,source) => {
             const {user} = params
 
             const renderedUsers: string[] = []
-            await openticket.blacklist.loopAll((blacklist,id) => {renderedUsers.push(discord.userMention(id.value)+" - "+(blacklist.reason ? blacklist.reason : "/"))})
+            await opendiscord.blacklist.loopAll((blacklist,id) => {renderedUsers.push(discord.userMention(id.value)+" - "+(blacklist.reason ? blacklist.reason : "/"))})
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
             instance.setColor(generalConfig.data.mainColor)
@@ -896,11 +896,11 @@ const blacklistEmbeds = () => {
         })
     )
     //BLACKLIST GET
-    embeds.add(new api.ODEmbed("openticket:blacklist-get"))
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-get"))
-    embeds.get("openticket:blacklist-get").workers.add(
+    embeds.get("opendiscord:blacklist-get").workers.add(
-        new api.ODWorker("openticket:blacklist-get",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:blacklist-get",0,async (instance,params,source) => {
             const {user,data} = params
-            const blacklist = openticket.blacklist.get(data.id)
+            const blacklist = opendiscord.blacklist.get(data.id)
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
             instance.setColor(generalConfig.data.mainColor)
@@ -915,9 +915,9 @@ const blacklistEmbeds = () => {
     )
 
     //BLACKLIST ADD
-    embeds.add(new api.ODEmbed("openticket:blacklist-add"))
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-add"))
-    embeds.get("openticket:blacklist-add").workers.add(
+    embeds.get("opendiscord:blacklist-add").workers.add(
-        new api.ODWorker("openticket:blacklist-add",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:blacklist-add",0,async (instance,params,source) => {
             const {user,data,reason} = params
             
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -929,9 +929,9 @@ const blacklistEmbeds = () => {
     )
 
     //BLACKLIST REMOVE
-    embeds.add(new api.ODEmbed("openticket:blacklist-remove"))
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-remove"))
-    embeds.get("openticket:blacklist-remove").workers.add(
+    embeds.get("opendiscord:blacklist-remove").workers.add(
-        new api.ODWorker("openticket:blacklist-remove",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:blacklist-remove",0,async (instance,params,source) => {
             const {user,data,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -943,9 +943,9 @@ const blacklistEmbeds = () => {
     )
 
     //BLACKLIST DM
-    embeds.add(new api.ODEmbed("openticket:blacklist-dm"))
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-dm"))
-    embeds.get("openticket:blacklist-dm").workers.add(
+    embeds.get("opendiscord:blacklist-dm").workers.add(
-        new api.ODWorker("openticket:blacklist-dm",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:blacklist-dm",0,async (instance,params,source) => {
             const {user,mode,data,reason} = params
             
             const title = (mode == "add") ? lang.getTranslation("actions.titles.blacklistAddDm") : lang.getTranslation("actions.titles.blacklistRemoveDm")
@@ -960,9 +960,9 @@ const blacklistEmbeds = () => {
     )
 
     //BLACKLIST LOGS
-    embeds.add(new api.ODEmbed("openticket:blacklist-logs"))
+    embeds.add(new api.ODEmbed("opendiscord:blacklist-logs"))
-    embeds.get("openticket:blacklist-logs").workers.add(
+    embeds.get("opendiscord:blacklist-logs").workers.add(
-        new api.ODWorker("openticket:blacklist-logs",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:blacklist-logs",0,async (instance,params,source) => {
             const {user,mode,data,reason} = params
             
             const title = (mode == "add") ? lang.getTranslation("actions.titles.blacklistAdd") : lang.getTranslation("actions.titles.blacklistRemove")
@@ -981,17 +981,18 @@ const blacklistEmbeds = () => {
 
 const transcriptEmbeds = () => {
     //TRANSCRIPT TEXT READY
-    embeds.add(new api.ODEmbed("openticket:transcript-text-ready"))
+    embeds.add(new api.ODEmbed("opendiscord:transcript-text-ready"))
-    embeds.get("openticket:transcript-text-ready").workers.add(
+    embeds.get("opendiscord:transcript-text-ready").workers.add(
-        new api.ODWorker("openticket:transcript-text-ready",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:transcript-text-ready",0,async (instance,params,source) => {
             const {guild,channel,user,ticket,compiler} = params
+            const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")
             
-            instance.setColor(generalConfig.data.mainColor)
+            instance.setColor(transcriptConfig.data.embedSettings.customColor ? transcriptConfig.data.embedSettings.customColor : generalConfig.data.mainColor)
             instance.setTitle(utilities.emojiTitle("📄",lang.getTranslation("transcripts.success.ready")))
             instance.setTimestamp(new Date())
             instance.addFields({name:lang.getTranslation("params.uppercase.ticket")+":",value:"#"+channel.name,inline:false})
 
-            const creatorId = ticket.get("openticket:opened-by").value
+            const creatorId = ticket.get("opendiscord:opened-by").value
             if (creatorId){
                 try{
                     const creator = await channel.client.users.fetch(creatorId)
@@ -1010,18 +1011,19 @@ const transcriptEmbeds = () => {
     )
 
     //TRANSCRIPT HTML READY
-    embeds.add(new api.ODEmbed("openticket:transcript-html-ready"))
+    embeds.add(new api.ODEmbed("opendiscord:transcript-html-ready"))
-    embeds.get("openticket:transcript-html-ready").workers.add(
+    embeds.get("opendiscord:transcript-html-ready").workers.add(
-        new api.ODWorker("openticket:transcript-html-ready",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:transcript-html-ready",0,async (instance,params,source) => {
             const {guild,channel,user,ticket,compiler,result} = params
+            const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")
             
-            instance.setColor(generalConfig.data.mainColor)
+            instance.setColor(transcriptConfig.data.embedSettings.customColor ? transcriptConfig.data.embedSettings.customColor : generalConfig.data.mainColor)
             instance.setTitle(utilities.emojiTitle("📄",lang.getTranslation("transcripts.success.ready")))
             instance.setTimestamp(new Date())
             instance.addFields({name:lang.getTranslation("params.uppercase.ticket")+":",value:"#"+channel.name,inline:false})
             if (result.data) instance.setUrl(result.data.url)
 
-            const creatorId = ticket.get("openticket:opened-by").value
+            const creatorId = ticket.get("opendiscord:opened-by").value
             if (creatorId){
                 try{
                     const creator = await channel.client.users.fetch(creatorId)
@@ -1040,9 +1042,9 @@ const transcriptEmbeds = () => {
     )
 
     //TRANSCRIPT HTML PROGRESS
-    embeds.add(new api.ODEmbed("openticket:transcript-html-progress"))
+    embeds.add(new api.ODEmbed("opendiscord:transcript-html-progress"))
-    embeds.get("openticket:transcript-html-progress").workers.add(
+    embeds.get("opendiscord:transcript-html-progress").workers.add(
-        new api.ODWorker("openticket:transcript-html-progress",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:transcript-html-progress",0,async (instance,params,source) => {
             const {guild,channel,user,ticket,compiler,remaining} = params
             
             const remainingDate = new Date(new Date().getTime()+remaining)
@@ -1054,7 +1056,7 @@ const transcriptEmbeds = () => {
             instance.addFields({name:lang.getTranslation("params.uppercase.remaining")+":",value:discord.time(remainingDate,"R"),inline:false})
             instance.addFields({name:lang.getTranslation("params.uppercase.ticket")+":",value:"#"+channel.name,inline:false})
 
-            const creatorId = ticket.get("openticket:opened-by").value
+            const creatorId = ticket.get("opendiscord:opened-by").value
             if (creatorId){
                 try{
                     const creator = await channel.client.users.fetch(creatorId)
@@ -1066,9 +1068,9 @@ const transcriptEmbeds = () => {
     )
 
     //TRANSCRIPT ERROR
-    embeds.add(new api.ODEmbed("openticket:transcript-error"))
+    embeds.add(new api.ODEmbed("opendiscord:transcript-error"))
-    embeds.get("openticket:transcript-error").workers.add(
+    embeds.get("opendiscord:transcript-error").workers.add(
-        new api.ODWorker("openticket:transcript-error",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:transcript-error",0,async (instance,params,source) => {
             const {guild,channel,user,ticket,compiler,reason} = params
             
             instance.setColor(generalConfig.data.system.useRedErrorEmbeds ? "Red" : generalConfig.data.mainColor)
@@ -1083,9 +1085,9 @@ const transcriptEmbeds = () => {
 
 const roleEmbeds = () => {
     //REACTION ROLE
-    embeds.add(new api.ODEmbed("openticket:reaction-role"))
+    embeds.add(new api.ODEmbed("opendiscord:reaction-role"))
-    embeds.get("openticket:reaction-role").workers.add(
+    embeds.get("opendiscord:reaction-role").workers.add(
-        new api.ODWorker("openticket:reaction-role",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:reaction-role",0,async (instance,params,source) => {
             const {guild,user,role,result} = params
 
             instance.setColor(generalConfig.data.mainColor)
@@ -1109,9 +1111,9 @@ const roleEmbeds = () => {
 
 const clearEmbeds = () => {
     //CLEAR VERIFY MESSAGE
-    embeds.add(new api.ODEmbed("openticket:clear-verify-message"))
+    embeds.add(new api.ODEmbed("opendiscord:clear-verify-message"))
-    embeds.get("openticket:clear-verify-message").workers.add(
+    embeds.get("opendiscord:clear-verify-message").workers.add(
-        new api.ODWorker("openticket:clear-verify-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:clear-verify-message",0,async (instance,params,source) => {
             const {guild,channel,user,filter,list} = params
             
             instance.setColor(generalConfig.data.mainColor)
@@ -1127,9 +1129,9 @@ const clearEmbeds = () => {
     )
 
     //CLEAR MESSAGE
-    embeds.add(new api.ODEmbed("openticket:clear-message"))
+    embeds.add(new api.ODEmbed("opendiscord:clear-message"))
-    embeds.get("openticket:clear-message").workers.add(
+    embeds.get("opendiscord:clear-message").workers.add(
-        new api.ODWorker("openticket:clear-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:clear-message",0,async (instance,params,source) => {
             const {guild,channel,user,filter,list} = params
             
             instance.setColor(generalConfig.data.mainColor)
@@ -1144,9 +1146,9 @@ const clearEmbeds = () => {
     )
 
     //CLEAR LOGS
-    embeds.add(new api.ODEmbed("openticket:clear-logs"))
+    embeds.add(new api.ODEmbed("opendiscord:clear-logs"))
-    embeds.get("openticket:clear-logs").workers.add(
+    embeds.get("opendiscord:clear-logs").workers.add(
-        new api.ODWorker("openticket:clear-logs",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:clear-logs",0,async (instance,params,source) => {
             const {guild,channel,user,filter,list} = params
             
             instance.setColor(generalConfig.data.mainColor)
@@ -1162,32 +1164,13 @@ const clearEmbeds = () => {
     )
 }
 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE 
-//TRANSLATION FINISHED UNTIL HERE  
-
 const autoEmbeds = () => {
     //AUTOCLOSE MESSAGE
-    embeds.add(new api.ODEmbed("openticket:autoclose-message"))
+    embeds.add(new api.ODEmbed("opendiscord:autoclose-message"))
-    embeds.get("openticket:autoclose-message").workers.add(
+    embeds.get("opendiscord:autoclose-message").workers.add(
-        new api.ODWorker("openticket:autoclose-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:autoclose-message",0,async (instance,params,source) => {
             const {user,ticket} = params
-            const hours: number = ticket.get("openticket:autoclose-hours").value
+            const hours: number = ticket.get("opendiscord:autoclose-hours").value
             const description = (source == "leave") ? lang.getTranslation("actions.descriptions.autocloseLeave") : lang.getTranslationWithParams("actions.descriptions.autocloseTimeout",[hours.toString()])
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1199,11 +1182,11 @@ const autoEmbeds = () => {
     )
 
     //AUTODELETE MESSAGE
-    embeds.add(new api.ODEmbed("openticket:autodelete-message"))
+    embeds.add(new api.ODEmbed("opendiscord:autodelete-message"))
-    embeds.get("openticket:autodelete-message").workers.add(
+    embeds.get("opendiscord:autodelete-message").workers.add(
-        new api.ODWorker("openticket:autodelete-message",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:autodelete-message",0,async (instance,params,source) => {
             const {user,ticket} = params
-            const days: number = ticket.get("openticket:autodelete-days").value
+            const days: number = ticket.get("opendiscord:autodelete-days").value
             const description = (source == "leave") ? lang.getTranslation("actions.descriptions.autodeleteLeave") : lang.getTranslationWithParams("actions.descriptions.autodeleteTimeout",[days.toString()])
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1215,9 +1198,9 @@ const autoEmbeds = () => {
     )
 
     //AUTOCLOSE ENABLE
-    embeds.add(new api.ODEmbed("openticket:autoclose-enable"))
+    embeds.add(new api.ODEmbed("opendiscord:autoclose-enable"))
-    embeds.get("openticket:autoclose-enable").workers.add(
+    embeds.get("opendiscord:autoclose-enable").workers.add(
-        new api.ODWorker("openticket:autoclose-enable",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:autoclose-enable",0,async (instance,params,source) => {
             const {user,ticket,reason,time} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1229,9 +1212,9 @@ const autoEmbeds = () => {
     )
 
     //AUTODELETE ENABLE
-    embeds.add(new api.ODEmbed("openticket:autodelete-enable"))
+    embeds.add(new api.ODEmbed("opendiscord:autodelete-enable"))
-    embeds.get("openticket:autodelete-enable").workers.add(
+    embeds.get("opendiscord:autodelete-enable").workers.add(
-        new api.ODWorker("openticket:autodelete-enable",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:autodelete-enable",0,async (instance,params,source) => {
             const {user,ticket,reason,time} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1243,9 +1226,9 @@ const autoEmbeds = () => {
     )
 
     //AUTOCLOSE DISABLE
-    embeds.add(new api.ODEmbed("openticket:autoclose-disable"))
+    embeds.add(new api.ODEmbed("opendiscord:autoclose-disable"))
-    embeds.get("openticket:autoclose-disable").workers.add(
+    embeds.get("opendiscord:autoclose-disable").workers.add(
-        new api.ODWorker("openticket:autoclose-disable",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:autoclose-disable",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())
@@ -1257,9 +1240,9 @@ const autoEmbeds = () => {
     )
 
     //AUTODELETE DISABLE
-    embeds.add(new api.ODEmbed("openticket:autodelete-disable"))
+    embeds.add(new api.ODEmbed("opendiscord:autodelete-disable"))
-    embeds.get("openticket:autodelete-disable").workers.add(
+    embeds.get("opendiscord:autodelete-disable").workers.add(
-        new api.ODWorker("openticket:autodelete-disable",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:autodelete-disable",0,async (instance,params,source) => {
             const {user,ticket,reason} = params
 
             instance.setAuthor(user.displayName,user.displayAvatarURL())

src/builders/files.ts

@@ -1,12 +1,12 @@
 ///////////////////////////////////////
 //FILE BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const files = openticket.builders.files
+const files = opendiscord.builders.files
-const lang = openticket.languages
+const lang = opendiscord.languages
-const transcriptConfig = openticket.configs.get("openticket:transcripts")
+const transcriptConfig = opendiscord.configs.get("opendiscord:transcripts")
 
 export const registerAllFiles = async () => {
     transcriptFiles()
@@ -15,16 +15,16 @@ export const registerAllFiles = async () => {
 
 const transcriptFiles = () => {
     //TEXT TRANSCRIPT
-    files.add(new api.ODFile("openticket:text-transcript"))
+    files.add(new api.ODFile("opendiscord:text-transcript"))
-    files.get("openticket:text-transcript").workers.add(
+    files.get("opendiscord:text-transcript").workers.add(
-        new api.ODWorker("openticket:text-transcript",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:text-transcript",0,async (instance,params,source) => {
             const {guild,channel,user,ticket,compiler,result} = params
             
             const fileMode = transcriptConfig.data.textTranscriptStyle.fileMode
             const customName = transcriptConfig.data.textTranscriptStyle.customFileName
 
-            const creatorId = ticket.get("openticket:opened-by").value ?? "unknown-creator-id"
+            const creatorId = ticket.get("opendiscord:opened-by").value ?? "unknown-creator-id"
-            const creator = (await openticket.tickets.getTicketUser(ticket,"creator"))
+            const creator = (await opendiscord.tickets.getTicketUser(ticket,"creator"))
 
             if (fileMode == "custom") instance.setName(customName.split(".")[0]+".txt")
             else if (fileMode == "user-id") instance.setName(creatorId+".txt")
@@ -35,7 +35,7 @@ const transcriptFiles = () => {
 
             instance.setDescription(lang.getTranslation("transcripts.success.textFileDescription"))
             
-            if (compiler.id.value != "openticket:text-compiler" || !result.data || typeof result.data.contents != "string"){
+            if (compiler.id.value != "opendiscord:text-compiler" || !result.data || typeof result.data.contents != "string"){
                 instance.setContents("<invalid-transcript-compiler>")
                 return
             }

src/builders/modals.ts

@@ -1,54 +1,54 @@
 ///////////////////////////////////////
 //MODAL BUILDERS
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const modals = openticket.builders.modals
+const modals = opendiscord.builders.modals
-const lang = openticket.languages
+const lang = opendiscord.languages
 
 export const registerAllModals = async () => {
     ticketModals()
 }
 const ticketModals = () => {
     //TICKET QUESTIONS
-    modals.add(new api.ODModal("openticket:ticket-questions"))
+    modals.add(new api.ODModal("opendiscord:ticket-questions"))
-    modals.get("openticket:ticket-questions").workers.add(
+    modals.get("opendiscord:ticket-questions").workers.add(
-        new api.ODWorker("openticket:ticket-questions",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:ticket-questions",0,async (instance,params,source) => {
             const {option} = params
             
             instance.setCustomId("od:ticket-questions_"+option.id.value+"_"+source)
-            instance.setTitle(option.exists("openticket:name") ? option.get("openticket:name").value : option.id.value)
+            instance.setTitle(option.exists("opendiscord:name") ? option.get("opendiscord:name").value : option.id.value)
-            const questionIds = option.get("openticket:questions").value
+            const questionIds = option.get("opendiscord:questions").value
             questionIds.forEach((id) => {
-                const question = openticket.questions.get(id)
+                const question = opendiscord.questions.get(id)
                 if (!question) return
                 if (question instanceof api.ODShortQuestion) instance.addQuestion({
                     customId:question.id.value,
-                    label:question.get("openticket:name").value,
+                    label:question.get("opendiscord:name").value,
                     style:"short",
-                    required:question.get("openticket:required").value,
+                    required:question.get("opendiscord:required").value,
-                    placeholder:(question.get("openticket:placeholder").value) ? question.get("openticket:placeholder").value : undefined,
+                    placeholder:(question.get("opendiscord:placeholder").value) ? question.get("opendiscord:placeholder").value : undefined,
-                    minLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-min").value : undefined,
+                    minLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-min").value : undefined,
-                    maxLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-max").value : undefined
+                    maxLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-max").value : undefined
                 })
                 else if (question instanceof api.ODParagraphQuestion) instance.addQuestion({
                     customId:question.id.value,
-                    label:question.get("openticket:name").value,
+                    label:question.get("opendiscord:name").value,
                     style:"paragraph",
-                    required:question.get("openticket:required").value,
+                    required:question.get("opendiscord:required").value,
-                    placeholder:(question.get("openticket:placeholder").value) ? question.get("openticket:placeholder").value : undefined,
+                    placeholder:(question.get("opendiscord:placeholder").value) ? question.get("opendiscord:placeholder").value : undefined,
-                    minLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-min").value : undefined,
+                    minLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-min").value : undefined,
-                    maxLength:(question.get("openticket:length-enabled").value) ? question.get("openticket:length-max").value : undefined
+                    maxLength:(question.get("opendiscord:length-enabled").value) ? question.get("opendiscord:length-max").value : undefined
                 })
             })
         })
     )
 
     //CLOSE TICKET REASON
-    modals.add(new api.ODModal("openticket:close-ticket-reason"))
+    modals.add(new api.ODModal("opendiscord:close-ticket-reason"))
-    modals.get("openticket:close-ticket-reason").workers.add(
+    modals.get("opendiscord:close-ticket-reason").workers.add(
-        new api.ODWorker("openticket:close-ticket-reason",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:close-ticket-reason",0,async (instance,params,source) => {
             const {ticket} = params
 
             instance.setCustomId("od:close-ticket-reason_"+ticket.id.value+"_"+source)
@@ -64,9 +64,9 @@ const ticketModals = () => {
     )
 
     //REOPEN TICKET REASON
-    modals.add(new api.ODModal("openticket:reopen-ticket-reason"))
+    modals.add(new api.ODModal("opendiscord:reopen-ticket-reason"))
-    modals.get("openticket:reopen-ticket-reason").workers.add(
+    modals.get("opendiscord:reopen-ticket-reason").workers.add(
-        new api.ODWorker("openticket:reopen-ticket-reason",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:reopen-ticket-reason",0,async (instance,params,source) => {
             const {ticket} = params
 
             instance.setCustomId("od:reopen-ticket-reason_"+ticket.id.value+"_"+source)
@@ -82,9 +82,9 @@ const ticketModals = () => {
     )
 
     //DELETE TICKET REASON
-    modals.add(new api.ODModal("openticket:delete-ticket-reason"))
+    modals.add(new api.ODModal("opendiscord:delete-ticket-reason"))
-    modals.get("openticket:delete-ticket-reason").workers.add(
+    modals.get("opendiscord:delete-ticket-reason").workers.add(
-        new api.ODWorker("openticket:delete-ticket-reason",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:delete-ticket-reason",0,async (instance,params,source) => {
             const {ticket} = params
 
             instance.setCustomId("od:delete-ticket-reason_"+ticket.id.value+"_"+source)
@@ -100,9 +100,9 @@ const ticketModals = () => {
     )
 
     //CLAIM TICKET REASON
-    modals.add(new api.ODModal("openticket:claim-ticket-reason"))
+    modals.add(new api.ODModal("opendiscord:claim-ticket-reason"))
-    modals.get("openticket:claim-ticket-reason").workers.add(
+    modals.get("opendiscord:claim-ticket-reason").workers.add(
-        new api.ODWorker("openticket:claim-ticket-reason",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:claim-ticket-reason",0,async (instance,params,source) => {
             const {ticket} = params
 
             instance.setCustomId("od:claim-ticket-reason_"+ticket.id.value+"_"+source)
@@ -118,9 +118,9 @@ const ticketModals = () => {
     )
 
     //UNCLAIM TICKET REASON
-    modals.add(new api.ODModal("openticket:unclaim-ticket-reason"))
+    modals.add(new api.ODModal("opendiscord:unclaim-ticket-reason"))
-    modals.get("openticket:unclaim-ticket-reason").workers.add(
+    modals.get("opendiscord:unclaim-ticket-reason").workers.add(
-        new api.ODWorker("openticket:unclaim-ticket-reason",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:unclaim-ticket-reason",0,async (instance,params,source) => {
             const {ticket} = params
 
             instance.setCustomId("od:unclaim-ticket-reason_"+ticket.id.value+"_"+source)
@@ -136,9 +136,9 @@ const ticketModals = () => {
     )
 
     //PIN TICKET REASON
-    modals.add(new api.ODModal("openticket:pin-ticket-reason"))
+    modals.add(new api.ODModal("opendiscord:pin-ticket-reason"))
-    modals.get("openticket:pin-ticket-reason").workers.add(
+    modals.get("opendiscord:pin-ticket-reason").workers.add(
-        new api.ODWorker("openticket:pin-ticket-reason",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:pin-ticket-reason",0,async (instance,params,source) => {
             const {ticket} = params
 
             instance.setCustomId("od:pin-ticket-reason_"+ticket.id.value+"_"+source)
@@ -154,9 +154,9 @@ const ticketModals = () => {
     )
 
     //UNPIN TICKET REASON
-    modals.add(new api.ODModal("openticket:unpin-ticket-reason"))
+    modals.add(new api.ODModal("opendiscord:unpin-ticket-reason"))
-    modals.get("openticket:unpin-ticket-reason").workers.add(
+    modals.get("opendiscord:unpin-ticket-reason").workers.add(
-        new api.ODWorker("openticket:unpin-ticket-reason",0,async (instance,params,source) => {
+        new api.ODWorker("opendiscord:unpin-ticket-reason",0,async (instance,params,source) => {
             const {ticket} = params
 
             instance.setCustomId("od:unpin-ticket-reason_"+ticket.id.value+"_"+source)

src/commands/add.ts

@@ -1,62 +1,62 @@
 ///////////////////////////////////////
 //ADD COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //ADD COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:add",generalConfig.data.prefix,"add"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:add",generalConfig.data.prefix,"add"))
-    openticket.responders.commands.get("openticket:add").workers.add([
+    opendiscord.responders.commands.get("opendiscord:add").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.add
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:add",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:add",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -64,19 +64,19 @@ export const registerCommandResponders = async () => {
             const reason = instance.options.getString("reason",false)
 
             //return when user already added to ticket
-            const participants = await openticket.tickets.getAllTicketParticipants(ticket)
+            const participants = await opendiscord.tickets.getAllTicketParticipants(ticket)
             if (!participants || participants.find((p) => p.user.id == data.id)){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.add"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.add"),layout:"simple"}))
                 return cancel()
             }
 
             //start adding user to ticket
             await instance.defer(false)
-            await openticket.actions.get("openticket:add-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
+            await opendiscord.actions.get("opendiscord:add-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:add-message").build(source,{guild,channel,user,ticket,reason,data}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:add-message").build(source,{guild,channel,user,ticket,reason,data}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'add' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'add' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},

src/commands/autoclose.ts

@@ -1,68 +1,68 @@
 ///////////////////////////////////////
 //AUTOCLOSE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //AUTOCLOSE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:autoclose",generalConfig.data.prefix,/^autoclose/))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:autoclose",generalConfig.data.prefix,/^autoclose/))
-    openticket.responders.commands.get("openticket:autoclose").workers.add([
+    opendiscord.responders.commands.get("opendiscord:autoclose").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.autoclose
             
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:autoclose",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:autoclose",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return
             }
             //return when already closed
-            if (ticket.get("openticket:closed").value){
+            if (ticket.get("opendiscord:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -71,38 +71,38 @@ export const registerCommandResponders = async () => {
 
             if (scope == "disable"){
                 const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autoclose-enabled").value = false
+                ticket.get("opendiscord:autoclose-enabled").value = false
-                ticket.get("openticket:autoclose-hours").value = 0
+                ticket.get("opendiscord:autoclose-hours").value = 0
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autoclose-disable").build(source,{guild,channel,user,ticket,reason}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-disable").build(source,{guild,channel,user,ticket,reason}))
             
             }else if (scope == "enable"){
                 const time = instance.options.getNumber("time",true)
                 const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autoclose-enabled").value = true
+                ticket.get("opendiscord:autoclose-enabled").value = true
-                ticket.get("openticket:autoclose-hours").value = time
+                ticket.get("opendiscord:autoclose-hours").value = time
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autoclose-enable").build(source,{guild,channel,user,ticket,reason,time}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autoclose-enable").build(source,{guild,channel,user,ticket,reason,time}))
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on autoclose "+scope+"!","error",[
+                    opendiscord.log("Unable to edit ticket message on autoclose "+scope+"!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
             const scope = instance.options.getSubCommand()
             const reason = instance.options.getString("reason",false)
-            openticket.log(instance.user.displayName+" used the 'autoclose "+scope+"' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'autoclose "+scope+"' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},

src/commands/autodelete.ts

@@ -1,63 +1,63 @@
 ///////////////////////////////////////
 //AUTODELETE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //AUTODELETE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:autodelete",generalConfig.data.prefix,/^autodelete/))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:autodelete",generalConfig.data.prefix,/^autodelete/))
-    openticket.responders.commands.get("openticket:autodelete").workers.add([
+    opendiscord.responders.commands.get("opendiscord:autodelete").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.autodelete
             
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:autodelete",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:autodelete",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -66,38 +66,38 @@ export const registerCommandResponders = async () => {
 
             if (scope == "disable"){
                 const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autodelete-enabled").value = false
+                ticket.get("opendiscord:autodelete-enabled").value = false
-                ticket.get("openticket:autodelete-days").value = 0
+                ticket.get("opendiscord:autodelete-days").value = 0
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autodelete-disable").build(source,{guild,channel,user,ticket,reason}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autodelete-disable").build(source,{guild,channel,user,ticket,reason}))
             
             }else if (scope == "enable"){
                 const time = instance.options.getNumber("time",true)
                 const reason = instance.options.getString("reason",false)
-                ticket.get("openticket:autodelete-enabled").value = true
+                ticket.get("opendiscord:autodelete-enabled").value = true
-                ticket.get("openticket:autodelete-days").value = time
+                ticket.get("opendiscord:autodelete-days").value = time
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:autodelete-enable").build(source,{guild,channel,user,ticket,reason,time}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:autodelete-enable").build(source,{guild,channel,user,ticket,reason,time}))
             }
 
             //update ticket message
-            const ticketMessage = await openticket.tickets.getTicketMessage(ticket)
+            const ticketMessage = await opendiscord.tickets.getTicketMessage(ticket)
             if (ticketMessage){
                 try{
-                    ticketMessage.edit((await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket})).message)
+                    ticketMessage.edit((await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket})).message)
                 }catch(e){
-                    openticket.log("Unable to edit ticket message on autodelete "+scope+"!","error",[
+                    opendiscord.log("Unable to edit ticket message on autodelete "+scope+"!","error",[
                         {key:"channel",value:"#"+channel.name},
                         {key:"channelid",value:channel.id,hidden:true},
                         {key:"messageid",value:ticketMessage.id},
                         {key:"option",value:ticket.option.id.value}
                     ])
-                    openticket.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
+                    opendiscord.debugfile.writeErrorMessage(new api.ODError(e,"uncaughtException"))
                 }
             }
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
             const scope = instance.options.getSubCommand()
             const reason = instance.options.getString("reason",false)
-            openticket.log(instance.user.displayName+" used the 'autodelete "+scope+"' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'autodelete "+scope+"' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},

src/commands/blacklist.ts

@@ -1,71 +1,71 @@
 ///////////////////////////////////////
 //BLACKLIST COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //BLACKLIST COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:blacklist",generalConfig.data.prefix,/^blacklist/))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:blacklist",generalConfig.data.prefix,/^blacklist/))
-    openticket.responders.commands.get("openticket:blacklist").workers.add([
+    opendiscord.responders.commands.get("opendiscord:blacklist").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.blacklist
             
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:blacklist",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:blacklist",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                 return cancel()
             }
             const scope = instance.options.getSubCommand()
             if (!scope || (scope != "add" && scope != "get" && scope != "remove" && scope != "view")) return
 
             if (scope == "view"){
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-view").build(source,{guild,channel,user}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-view").build(source,{guild,channel,user}))
             
             }else if (scope == "get"){
                 const data = instance.options.getUser("user",true)
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-get").build(source,{guild,channel,user,data}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-get").build(source,{guild,channel,user,data}))
 
             }else if (scope == "add"){
                 const data = instance.options.getUser("user",true)
                 const reason = instance.options.getString("reason",false)
 
-                openticket.blacklist.add(new api.ODBlacklist(data.id,reason),true)
+                opendiscord.blacklist.add(new api.ODBlacklist(data.id,reason),true)
-                openticket.log(instance.user.displayName+" added "+data.displayName+" to blacklist!","info",[
+                opendiscord.log(instance.user.displayName+" added "+data.displayName+" to blacklist!","info",[
                     {key:"user",value:user.username},
                     {key:"userid",value:user.id,hidden:true},
                     {key:"channelid",value:channel.id,hidden:true},
@@ -74,17 +74,17 @@ export const registerCommandResponders = async () => {
                 ])
 
                 //manage stats
-                await openticket.stats.get("openticket:global").setStat("openticket:users-blacklisted",1,"increase")
+                await opendiscord.stats.get("opendiscord:global").setStat("opendiscord:users-blacklisted",1,"increase")
-                await openticket.stats.get("openticket:user").setStat("openticket:users-blacklisted",user.id,1,"increase")
+                await opendiscord.stats.get("opendiscord:user").setStat("opendiscord:users-blacklisted",user.id,1,"increase")
 
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-add").build(source,{guild,channel,user,data,reason}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-add").build(source,{guild,channel,user,data,reason}))
 
             }else if (scope == "remove"){
                 const data = instance.options.getUser("user",true)
                 const reason = instance.options.getString("reason",false)
 
-                openticket.blacklist.remove(data.id)
+                opendiscord.blacklist.remove(data.id)
-                openticket.log(instance.user.displayName+" removed "+data.displayName+" from blacklist!","info",[
+                opendiscord.log(instance.user.displayName+" removed "+data.displayName+" from blacklist!","info",[
                     {key:"user",value:user.username},
                     {key:"userid",value:user.id,hidden:true},
                     {key:"channelid",value:channel.id,hidden:true},
@@ -92,10 +92,10 @@ export const registerCommandResponders = async () => {
                     {key:"reason",value:reason ?? "/"}
                 ])
 
-                await instance.reply(await openticket.builders.messages.getSafe("openticket:blacklist-remove").build(source,{guild,channel,user,data,reason}))
+                await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-remove").build(source,{guild,channel,user,data,reason}))
             }
         }),
-        new api.ODWorker("openticket:discord-logs",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:discord-logs",1,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild) return
             
@@ -107,16 +107,16 @@ export const registerCommandResponders = async () => {
 
             //to logs
             if (generalConfig.data.system.logs.enabled && generalConfig.data.system.messages.blacklisting.logs){
-                const logChannel = openticket.posts.get("openticket:logs")
+                const logChannel = opendiscord.posts.get("opendiscord:logs")
-                if (logChannel) logChannel.send(await openticket.builders.messages.getSafe("openticket:blacklist-logs").build(source,{guild,channel,user,mode:scope,data,reason}))
+                if (logChannel) logChannel.send(await opendiscord.builders.messages.getSafe("opendiscord:blacklist-logs").build(source,{guild,channel,user,mode:scope,data,reason}))
             }
 
             //to dm
-            if (generalConfig.data.system.messages.blacklisting.dm) await openticket.client.sendUserDm(user,await openticket.builders.messages.getSafe("openticket:blacklist-dm").build(source,{guild,channel,user,mode:scope,data,reason}))
+            if (generalConfig.data.system.messages.blacklisting.dm) await opendiscord.client.sendUserDm(user,await opendiscord.builders.messages.getSafe("opendiscord:blacklist-dm").build(source,{guild,channel,user,mode:scope,data,reason}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
             const scope = instance.options.getSubCommand()
-            openticket.log(instance.user.displayName+" used the 'blacklist "+scope+"' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'blacklist "+scope+"' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},

src/commands/claim.ts

@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //CLAIM COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //CLAIM COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:claim",generalConfig.data.prefix,"claim"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:claim",generalConfig.data.prefix,"claim"))
-    openticket.responders.commands.get("openticket:claim").workers.add([
+    opendiscord.responders.commands.get("opendiscord:claim").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.claim
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:claim",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already claimed
-            if (ticket.get("openticket:claimed").value){
+            if (ticket.get("opendiscord:claimed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.claim"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -70,11 +70,11 @@ export const registerCommandResponders = async () => {
 
             //start claiming ticket
             await instance.defer(false)
-            await openticket.actions.get("openticket:claim-ticket").run(source,{guild,channel,user:claimUser,ticket,reason,sendMessage:false})
+            await opendiscord.actions.get("opendiscord:claim-ticket").run(source,{guild,channel,user:claimUser,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:claim-message").build(source,{guild,channel,user:claimUser,ticket,reason}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build(source,{guild,channel,user:claimUser,ticket,reason}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'claim' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'claim' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},
@@ -86,51 +86,51 @@ export const registerCommandResponders = async () => {
 
 export const registerButtonResponders = async () => {
     //CLAIM TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:claim-ticket",/^od:claim-ticket/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:claim-ticket",/^od:claim-ticket/))
-    openticket.responders.buttons.get("openticket:claim-ticket").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:claim-ticket").workers.add(
-        new api.ODWorker("openticket:claim-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:claim-ticket"]["source"],"slash"|"text">
-            if (originalSource != "ticket-message" && originalSource != "unclaim-message") return
             
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:claim-ticket-ticket-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:claim-ticket-ticket-message").activate(instance)
-            else await openticket.verifybars.get("openticket:claim-ticket-unclaim-message").activate(instance)
+            else if (originalSource == "unclaim-message") await opendiscord.verifybars.get("opendiscord:claim-ticket-unclaim-message").activate(instance)
+            else await instance.defer("update",false)
         })
     )
 }
 
 export const registerModalResponders = async () => {
     //CLAIM WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:claim-ticket-reason",/^od:claim-ticket-reason_/))
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:claim-ticket-reason",/^od:claim-ticket-reason_/))
-    openticket.responders.modals.get("openticket:claim-ticket-reason").workers.add([
+    opendiscord.responders.modals.get("opendiscord:claim-ticket-reason").workers.add([
-        new api.ODWorker("openticket:claim-ticket-reason",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:claim-ticket-reason",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!channel) return
             if (!guild){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return
             }
 
-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"unclaim-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:claim-ticket"]["source"],"slash"|"text">
             const reason = instance.values.getTextField("reason",true)
 
             //claim with reason
             if (originalSource == "ticket-message"){
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }else if (originalSource == "unclaim-message"){
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:claim-message").build("other",{guild,channel,user,ticket,reason}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:claim-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+            }else{
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:claim-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
             }
             
         })

src/commands/clear.ts

@@ -1,81 +1,81 @@
 ///////////////////////////////////////
 //CLEAR COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //CLEAR COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:clear",generalConfig.data.prefix,"clear"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:clear",generalConfig.data.prefix,"clear"))
-    openticket.responders.commands.get("openticket:clear").workers.add([
+    opendiscord.responders.commands.get("opendiscord:clear").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.clear
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
                 //only allow global admins (ticket admins aren't allowed to clear tickets)
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild,{allowChannelUserScope:false,allowChannelRoleScope:false}))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild,{allowChannelUserScope:false,allowChannelRoleScope:false}))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:clear",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:clear",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
             
             const tempFilter = instance.options.getString("filter",false)
             const filter = (tempFilter) ? tempFilter.toLowerCase() as api.ODTicketClearFilter : "all"
             const list: string[] = []
-            const ticketList = openticket.tickets.getAll().filter((ticket) => {
+            const ticketList = opendiscord.tickets.getAll().filter((ticket) => {
                 if (filter == "all") return true
-                else if (filter == "open" && ticket.get("openticket:open").value) return true
+                else if (filter == "open" && ticket.get("opendiscord:open").value) return true
-                else if (filter == "closed" && ticket.get("openticket:closed").value) return true
+                else if (filter == "closed" && ticket.get("opendiscord:closed").value) return true
-                else if (filter == "claimed" && ticket.get("openticket:claimed").value) return true
+                else if (filter == "claimed" && ticket.get("opendiscord:claimed").value) return true
-                else if (filter == "pinned" && ticket.get("openticket:pinned").value) return true
+                else if (filter == "pinned" && ticket.get("opendiscord:pinned").value) return true
-                else if (filter == "unclaimed" && !ticket.get("openticket:claimed").value) return true
+                else if (filter == "unclaimed" && !ticket.get("opendiscord:claimed").value) return true
-                else if (filter == "unpinned" && !ticket.get("openticket:pinned").value) return true
+                else if (filter == "unpinned" && !ticket.get("opendiscord:pinned").value) return true
-                else if (filter == "autoclosed" && ticket.get("openticket:closed").value) return true
+                else if (filter == "autoclosed" && ticket.get("opendiscord:closed").value) return true
                 else return false
             })
             for (const ticket of ticketList){
-                const ticketChannel = await openticket.tickets.getTicketChannel(ticket)
+                const ticketChannel = await opendiscord.tickets.getTicketChannel(ticket)
                 if (ticketChannel) list.push("#"+ticketChannel.name)
             }
 
             //reply with clear verify
             await instance.defer(true)
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:clear-verify-message").build(source,{guild,channel,user,filter,list}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:clear-verify-message").build(source,{guild,channel,user,filter,list}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'clear' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'clear' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},
@@ -87,36 +87,35 @@ export const registerCommandResponders = async () => {
 
 export const registerButtonResponders = async () => {
     //CLEAR CONTINUE BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:clear-continue",/^od:clear-continue_/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:clear-continue",/^od:clear-continue_/))
-    openticket.responders.buttons.get("openticket:clear-continue").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:clear-continue").workers.add(
-        new api.ODWorker("openticket:clear-continue",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:clear-continue",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild || channel.isDMBased()) return
-            const originalSource = instance.interaction.customId.split("_")[1]
+            const originalSource = instance.interaction.customId.split("_")[1] as api.ODActionManagerIds_Default["opendiscord:clear-tickets"]["source"]
-            if (originalSource != "slash" && originalSource != "text" && originalSource != "other") return
             const filter = instance.interaction.customId.split("_")[2] as api.ODTicketClearFilter
             
             //start ticket clear
-            instance.defer("update",true)
+            await instance.defer("update",true)
             const list: string[] = []
-            const ticketList = openticket.tickets.getAll().filter((ticket) => {
+            const ticketList = opendiscord.tickets.getAll().filter((ticket) => {
                 if (filter == "all") return true
-                else if (filter == "open" && ticket.get("openticket:open").value) return true
+                else if (filter == "open" && ticket.get("opendiscord:open").value) return true
-                else if (filter == "closed" && ticket.get("openticket:closed").value) return true
+                else if (filter == "closed" && ticket.get("opendiscord:closed").value) return true
-                else if (filter == "claimed" && ticket.get("openticket:claimed").value) return true
+                else if (filter == "claimed" && ticket.get("opendiscord:claimed").value) return true
-                else if (filter == "pinned" && ticket.get("openticket:pinned").value) return true
+                else if (filter == "pinned" && ticket.get("opendiscord:pinned").value) return true
-                else if (filter == "unclaimed" && !ticket.get("openticket:claimed").value) return true
+                else if (filter == "unclaimed" && !ticket.get("opendiscord:claimed").value) return true
-                else if (filter == "unpinned" && !ticket.get("openticket:pinned").value) return true
+                else if (filter == "unpinned" && !ticket.get("opendiscord:pinned").value) return true
-                else if (filter == "autoclosed" && ticket.get("openticket:closed").value) return true
+                else if (filter == "autoclosed" && ticket.get("opendiscord:closed").value) return true
                 else return false
             })
             for (const ticket of ticketList){
-                const ticketChannel = await openticket.tickets.getTicketChannel(ticket)
+                const ticketChannel = await opendiscord.tickets.getTicketChannel(ticket)
                 if (ticketChannel) list.push("#"+ticketChannel.name)
             }
 
-            await openticket.actions.get("openticket:clear-tickets").run(originalSource,{guild,channel,user,filter,list:ticketList})
+            await opendiscord.actions.get("opendiscord:clear-tickets").run(originalSource,{guild,channel,user,filter,list:ticketList})
-            await instance.update(await openticket.builders.messages.getSafe("openticket:clear-message").build(originalSource,{guild,channel,user,filter,list}))
+            await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:clear-message").build(originalSource,{guild,channel,user,filter,list}))
         })
     )
 }

src/commands/close.ts

@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //CLOSE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //CLOSE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:close",generalConfig.data.prefix,"close"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:close",generalConfig.data.prefix,"close"))
-    openticket.responders.commands.get("openticket:close").workers.add([
+    opendiscord.responders.commands.get("opendiscord:close").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.close
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:close",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already closed
-            if (ticket.get("openticket:closed").value){
+            if (ticket.get("opendiscord:closed").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.close"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -69,11 +69,11 @@ export const registerCommandResponders = async () => {
 
             //start closing ticket
             await instance.defer(false)
-            await openticket.actions.get("openticket:close-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
+            await opendiscord.actions.get("opendiscord:close-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:close-message").build(source,{guild,channel,user,ticket,reason}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build(source,{guild,channel,user,ticket,reason}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'close' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'close' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},
@@ -85,51 +85,51 @@ export const registerCommandResponders = async () => {
 
 export const registerButtonResponders = async () => {
     //CLOSE TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:close-ticket",/^od:close-ticket_/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:close-ticket",/^od:close-ticket_/))
-    openticket.responders.buttons.get("openticket:close-ticket").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:close-ticket").workers.add(
-        new api.ODWorker("openticket:close-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:close-ticket"]["source"],"slash"|"text"|"autoclose">
-            if (originalSource != "ticket-message" && originalSource != "reopen-message") return
             
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:close-ticket-ticket-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:close-ticket-ticket-message").activate(instance)
-            else await openticket.verifybars.get("openticket:close-ticket-reopen-message").activate(instance)
+            else if (originalSource == "reopen-message") await opendiscord.verifybars.get("opendiscord:close-ticket-reopen-message").activate(instance)
+            else await instance.defer("update",false)
         })
     )
 }
 
 export const registerModalResponders = async () => {
     //CLOSE WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:close-ticket-reason",/^od:close-ticket-reason_/))
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:close-ticket-reason",/^od:close-ticket-reason_/))
-    openticket.responders.modals.get("openticket:close-ticket-reason").workers.add([
+    opendiscord.responders.modals.get("opendiscord:close-ticket-reason").workers.add([
-        new api.ODWorker("openticket:close-ticket-reason",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:close-ticket-reason",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!channel) return
             if (!guild){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return
             }
 
-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"reopen-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:close-ticket"]["source"],"slash"|"text"|"autoclose">
             const reason = instance.values.getTextField("reason",true)
 
             //close with reason
             if (originalSource == "ticket-message"){
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }else if (originalSource == "reopen-message"){
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:close-message").build("other",{guild,channel,user,ticket,reason}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:close-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+            }else{
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:close-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
             }
             
         })

src/commands/delete.ts

@@ -1,62 +1,62 @@
 ///////////////////////////////////////
 //DELETE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //DELETE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:delete",generalConfig.data.prefix,"delete"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:delete",generalConfig.data.prefix,"delete"))
-    openticket.responders.commands.get("openticket:delete").workers.add([
+    opendiscord.responders.commands.get("opendiscord:delete").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.delete
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:delete",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -65,11 +65,11 @@ export const registerCommandResponders = async () => {
 
             //start deleting ticket
             await instance.defer(false)
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:delete-message").build(source,{guild,channel,user,ticket,reason}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build(source,{guild,channel,user,ticket,reason}))
-            await openticket.actions.get("openticket:delete-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript})
+            await opendiscord.actions.get("opendiscord:delete-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript})
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'delete' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'delete' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},
@@ -81,68 +81,68 @@ export const registerCommandResponders = async () => {
 
 export const registerButtonResponders = async () => {
     //DELETE TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:delete-ticket",/^od:delete-ticket/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:delete-ticket",/^od:delete-ticket/))
-    openticket.responders.buttons.get("openticket:delete-ticket").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:delete-ticket").workers.add(
-        new api.ODWorker("openticket:delete-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"],"slash"|"text"|"autodelete"|"clear">
-            if (originalSource != "ticket-message" && originalSource != "reopen-message" && originalSource != "close-message" && originalSource != "autoclose-message") return
             
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:delete-ticket-ticket-message").activate(instance)
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-ticket-message").activate(instance)
-            else if (originalSource == "close-message") await openticket.verifybars.get("openticket:delete-ticket-close-message").activate(instance)
+            else if (originalSource == "close-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-close-message").activate(instance)
-            else if (originalSource == "reopen-message") await openticket.verifybars.get("openticket:delete-ticket-reopen-message").activate(instance)
+            else if (originalSource == "reopen-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-reopen-message").activate(instance)
-            else if (originalSource == "autoclose-message") await openticket.verifybars.get("openticket:delete-ticket-autoclose-message").activate(instance)
+            else if (originalSource == "autoclose-message") await opendiscord.verifybars.get("opendiscord:delete-ticket-autoclose-message").activate(instance)
+            else await instance.defer("update",false)
         })
     )
 }
 
 export const registerModalResponders = async () => {
     //REOPEN WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:delete-ticket-reason",/^od:delete-ticket-reason_/))
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:delete-ticket-reason",/^od:delete-ticket-reason_/))
-    openticket.responders.modals.get("openticket:delete-ticket-reason").workers.add([
+    opendiscord.responders.modals.get("opendiscord:delete-ticket-reason").workers.add([
-        new api.ODWorker("openticket:delete-ticket-reason",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:delete-ticket-reason",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!channel) return
             if (!guild){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return
             }
 
-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"reopen-message"|"close-message"|"autoclose-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:delete-ticket"]["source"],"slash"|"text"|"autodelete"|"clear">
             const reason = instance.values.getTextField("reason",true)
 
             //delete with reason
             if (originalSource == "ticket-message"){
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
                 //update ticket (for ticket message) => no-await doesn't wait for the action to set this variable
-                ticket.get("openticket:for-deletion").value = true
+                ticket.get("opendiscord:for-deletion").value = true
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }else if (originalSource == "close-message"){
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason}))
             }else if (originalSource == "reopen-message"){
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason}))
             }else if (originalSource == "autoclose-message"){
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false,withoutTranscript:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:delete-message").build("other",{guild,channel,user,ticket,reason}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:delete-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+            }else{
                 await instance.defer("update",false)
                 //don't await DELETE action => else it will update the message after the channel has been deleted
-                openticket.actions.get("openticket:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
+                opendiscord.actions.get("opendiscord:delete-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true,withoutTranscript:false})
             }
         })
     ])

src/commands/help.ts

@@ -1,49 +1,49 @@
 ///////////////////////////////////////
 //HELP COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //HELP COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:help",generalConfig.data.prefix,"help"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:help",generalConfig.data.prefix,"help"))
-    openticket.responders.commands.get("openticket:help").workers.add([
+    opendiscord.responders.commands.get("opendiscord:help").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.help
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:help",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:help",0,async (instance,params,source,cancel) => {
             const preferSlashOverText = generalConfig.data.system.preferSlashOverText
             
             let mode: "slash"|"text"
@@ -53,10 +53,10 @@ export const registerCommandResponders = async () => {
             }else if (!generalConfig.data.slashCommands) mode = "text"
             else mode = "slash"
             
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:help-menu").build(source,{mode,page:0}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build(source,{mode,page:0}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'help' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'help' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},
@@ -68,44 +68,44 @@ export const registerCommandResponders = async () => {
 
 export const registerButtonResponders = async () => {
     //HELP MENU SWITCH BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:help-menu-switch",/^od:help-menu-switch_(slash|text)/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:help-menu-switch",/^od:help-menu-switch_(slash|text)/))
-    openticket.responders.buttons.get("openticket:help-menu-switch").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:help-menu-switch").workers.add(
-        new api.ODWorker("openticket:update-help-menu",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:update-help-menu",0,async (instance,params,source,cancel) => {
             const mode = instance.interaction.customId.split("_")[1] as "slash"|"text"
             const pageButton = instance.getMessageComponent("button",/^od:help-menu-page_([0-9]+)/)
             const currentPage = (pageButton && pageButton.customId) ? Number(pageButton.customId.split("_")[1]) : 0
 
             const newMode = (mode == "slash") ? "text" : "slash"
 
-            const msg = await openticket.builders.messages.getSafe("openticket:help-menu").build("button",{mode:newMode,page:currentPage})
+            const msg = await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build("button",{mode:newMode,page:currentPage})
             await instance.update(msg)
         })
     )
 
     //HELP MENU PREVIOUS BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:help-menu-previous",/^od:help-menu-previous/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:help-menu-previous",/^od:help-menu-previous/))
-    openticket.responders.buttons.get("openticket:help-menu-previous").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:help-menu-previous").workers.add(
-        new api.ODWorker("openticket:update-help-menu",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:update-help-menu",0,async (instance,params,source,cancel) => {
             const switchButton = instance.getMessageComponent("button",/^od:help-menu-switch_(slash|text)/)
             const pageButton = instance.getMessageComponent("button",/^od:help-menu-page_([0-9]+)/)
             const currentPage = (pageButton && pageButton.customId) ? Number(pageButton.customId.split("_")[1]) : 0
             const currentMode = (switchButton && switchButton.customId) ? switchButton.customId.split("_")[1] as "text"|"slash" : "slash"
 
-            const msg = await openticket.builders.messages.getSafe("openticket:help-menu").build("button",{mode:currentMode,page:currentPage-1})
+            const msg = await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build("button",{mode:currentMode,page:currentPage-1})
             await instance.update(msg)
         })
     )
 
     //HELP MENU NEXT BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:help-menu-next",/^od:help-menu-next/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:help-menu-next",/^od:help-menu-next/))
-    openticket.responders.buttons.get("openticket:help-menu-next").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:help-menu-next").workers.add(
-        new api.ODWorker("openticket:update-help-menu",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:update-help-menu",0,async (instance,params,source,cancel) => {
             const switchButton = instance.getMessageComponent("button",/^od:help-menu-switch_(slash|text)/)
             const pageButton = instance.getMessageComponent("button",/^od:help-menu-page_([0-9]+)/)
             const currentPage = (pageButton && pageButton.customId) ? Number(pageButton.customId.split("_")[1]) : 0
             const currentMode = (switchButton && switchButton.customId) ? switchButton.customId.split("_")[1] as "text"|"slash" : "slash"
 
-            const msg = await openticket.builders.messages.getSafe("openticket:help-menu").build("button",{mode:currentMode,page:currentPage+1})
+            const msg = await opendiscord.builders.messages.getSafe("opendiscord:help-menu").build("button",{mode:currentMode,page:currentPage+1})
             await instance.update(msg)
         })
     )

src/commands/move.ts

@@ -1,87 +1,87 @@
 ///////////////////////////////////////
 //MOVE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //MOVE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:move",generalConfig.data.prefix,"move"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:move",generalConfig.data.prefix,"move"))
-    openticket.responders.commands.get("openticket:move").workers.add([
+    opendiscord.responders.commands.get("opendiscord:move").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.move
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:move",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:move",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
             const id = instance.options.getString("id",true)
             const reason = instance.options.getString("reason",false)
 
-            const option = openticket.options.get(id)
+            const option = opendiscord.options.get(id)
             //return if unknown option
             if (!option || !(option instanceof api.ODTicketOption)){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.titles.unknownOption"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.titles.unknownOption"),layout:"simple"}))
                 return cancel()
             }
             //return if option is the same
             if (ticket.option.id.value == option.id.value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:"This ticket is already the same as the chosen option!",layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:"This ticket is already the same as the chosen option!",layout:"simple"}))
                 return cancel()
             }
 
             //start moving ticket
             await instance.defer(false)
-            await openticket.actions.get("openticket:move-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data:option})
+            await opendiscord.actions.get("opendiscord:move-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data:option})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:move-message").build(source,{guild,channel,user,ticket,reason,data:option}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:move-message").build(source,{guild,channel,user,ticket,reason,data:option}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'move' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'move' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},

src/commands/panel.ts

@@ -1,77 +1,80 @@
 ///////////////////////////////////////
 //STATS COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //PANEL COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:panel",generalConfig.data.prefix,/^panel/))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:panel",generalConfig.data.prefix,/^panel/))
-    openticket.responders.commands.get("openticket:panel").workers.add([
+    opendiscord.responders.commands.get("opendiscord:panel").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.panel
             
             //command is disabled
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:panel",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:panel",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild || instance.channel.type == discord.ChannelType.GroupDM){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel:instance.channel,user:instance.user}))
                 return cancel()
             }
             
             const id = instance.options.getString("id",true)
-            const panel = openticket.panels.get(id)
+            const panel = opendiscord.panels.get(id)
 
             if (!panel){
                 //invalid panel
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-panel-unknown").build(source,{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-panel-unknown").build(source,{guild,channel,user}))
                 return cancel()
             } 
             
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:panel-ready").build(source,{guild,channel,user,panel}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:panel-ready").build(source,{guild,channel,user,panel}))
-            const panelMessage = await instance.channel.send((await openticket.builders.messages.getSafe("openticket:panel").build(source,{guild,channel,user,panel})).message)
+            const panelMessage = await instance.channel.send((await opendiscord.builders.messages.getSafe("opendiscord:panel").build(source,{guild,channel,user,panel})).message)
 
-            //add panel to database on auto-update
+            //add panel to database (this way, the bot knows where all panels are located)
+            const globalDatabase = opendiscord.databases.get("opendiscord:global")
+            await globalDatabase.set("opendiscord:panel-message",panelMessage.channel.id+"_"+panelMessage.id,panel.id.value)
+            
+            //add panel to database for auto-update
             if (instance.options.getBoolean("auto-update",false)){
-                const globalDatabase = openticket.databases.get("openticket:global")
+                await globalDatabase.set("opendiscord:panel-update",panelMessage.channel.id+"_"+panelMessage.id,panel.id.value)
-                await globalDatabase.set("openticket:panel-update",panelMessage.channel.id+"_"+panelMessage.id,panel.id.value)
             }
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'panel' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'panel' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},

src/commands/pin.ts

@@ -1,67 +1,67 @@
 ///////////////////////////////////////
 //PIN COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //PIN COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:pin",generalConfig.data.prefix,"pin"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:pin",generalConfig.data.prefix,"pin"))
-    openticket.responders.commands.get("openticket:pin").workers.add([
+    opendiscord.responders.commands.get("opendiscord:pin").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.pin
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:pin",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when already pinned
-            if (ticket.get("openticket:pinned").value){
+            if (ticket.get("opendiscord:pinned").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.pin"),layout:"simple"}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -69,11 +69,11 @@ export const registerCommandResponders = async () => {
 
             //start pinning ticket
             await instance.defer(false)
-            await openticket.actions.get("openticket:pin-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
+            await opendiscord.actions.get("opendiscord:pin-ticket").run(source,{guild,channel,user,ticket,reason,sendMessage:false})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:pin-message").build(source,{guild,channel,user,ticket,reason}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build(source,{guild,channel,user,ticket,reason}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'pin' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'pin' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},
@@ -85,51 +85,51 @@ export const registerCommandResponders = async () => {
 
 export const registerButtonResponders = async () => {
     //PIN TICKET BUTTON RESPONDER
-    openticket.responders.buttons.add(new api.ODButtonResponder("openticket:pin-ticket",/^od:pin-ticket/))
+    opendiscord.responders.buttons.add(new api.ODButtonResponder("opendiscord:pin-ticket",/^od:pin-ticket/))
-    openticket.responders.buttons.get("openticket:pin-ticket").workers.add(
+    opendiscord.responders.buttons.get("opendiscord:pin-ticket").workers.add(
-        new api.ODWorker("openticket:pin-ticket",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin-ticket",0,async (instance,params,source,cancel) => {
-            const originalSource = instance.interaction.customId.split("_")[1]
+            const originalSource = instance.interaction.customId.split("_")[1] as Exclude<api.ODActionManagerIds_Default["opendiscord:pin-ticket"]["source"],"slash"|"text">
-            if (originalSource != "ticket-message" && originalSource != "unpin-message") return
+
-            
+            if (originalSource == "ticket-message") await opendiscord.verifybars.get("opendiscord:pin-ticket-ticket-message").activate(instance)
-            if (originalSource == "ticket-message") await openticket.verifybars.get("openticket:pin-ticket-ticket-message").activate(instance)
+            else if (originalSource == "unpin-message") await opendiscord.verifybars.get("opendiscord:pin-ticket-unpin-message").activate(instance)
-            else await openticket.verifybars.get("openticket:pin-ticket-unpin-message").activate(instance)
+            else await instance.defer("update",false)
         })
     )
 }
 
 export const registerModalResponders = async () => {
     //PIN WITH REASON MODAL RESPONDER
-    openticket.responders.modals.add(new api.ODModalResponder("openticket:pin-ticket-reason",/^od:pin-ticket-reason_/))
+    opendiscord.responders.modals.add(new api.ODModalResponder("opendiscord:pin-ticket-reason",/^od:pin-ticket-reason_/))
-    openticket.responders.modals.get("openticket:pin-ticket-reason").workers.add([
+    opendiscord.responders.modals.get("opendiscord:pin-ticket-reason").workers.add([
-        new api.ODWorker("openticket:pin-ticket-reason",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:pin-ticket-reason",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!channel) return
             if (!guild){
                 //error
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build(source,{channel,user:instance.user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build(source,{channel,user:instance.user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(instance.interaction.customId.split("_")[1])
+            const ticket = opendiscord.tickets.get(instance.interaction.customId.split("_")[1])
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return
             }
 
-            const originalSource = instance.interaction.customId.split("_")[2] as ("ticket-message"|"unpin-message"|"other")
+            const originalSource = instance.interaction.customId.split("_")[2] as Exclude<api.ODActionManagerIds_Default["opendiscord:pin-ticket"]["source"],"slash"|"text">
             const reason = instance.values.getTextField("reason",true)
 
             //pin with reason
             if (originalSource == "ticket-message"){
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:ticket-message").build("other",{guild,channel,user,ticket}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:ticket-message").build("other",{guild,channel,user,ticket}))
             }else if (originalSource == "unpin-message"){
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
+                await opendiscord.actions.get("opendiscord:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:false})
-                await instance.update(await openticket.builders.messages.getSafe("openticket:pin-message").build("other",{guild,channel,user,ticket,reason}))
+                await instance.update(await opendiscord.builders.messages.getSafe("opendiscord:pin-message").build("other",{guild,channel,user,ticket,reason}))
-            }else if (originalSource == "other"){
+            }else{
                 await instance.defer("update",false)
-                await openticket.actions.get("openticket:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
+                await opendiscord.actions.get("opendiscord:pin-ticket").run(originalSource,{guild,channel,user,ticket,reason,sendMessage:true})
             }
             
         })

src/commands/remove.ts

@@ -1,62 +1,62 @@
 ///////////////////////////////////////
 //REMOVE COMMAND
 ///////////////////////////////////////
-import {openticket, api, utilities} from "../index"
+import {opendiscord, api, utilities} from "../index"
 import * as discord from "discord.js"
 
-const generalConfig = openticket.configs.get("openticket:general")
+const generalConfig = opendiscord.configs.get("opendiscord:general")
 
 export const registerCommandResponders = async () => {
     //REMOVE COMMAND RESPONDER
-    openticket.responders.commands.add(new api.ODCommandResponder("openticket:remove",generalConfig.data.prefix,"remove"))
+    opendiscord.responders.commands.add(new api.ODCommandResponder("opendiscord:remove",generalConfig.data.prefix,"remove"))
-    openticket.responders.commands.get("openticket:remove").workers.add([
+    opendiscord.responders.commands.get("opendiscord:remove").workers.add([
-        new api.ODWorker("openticket:permissions",1,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:permissions",1,async (instance,params,source,cancel) => {
             const permissionMode = generalConfig.data.system.permissions.remove
 
             if (permissionMode == "none"){
                 //no permissions
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build("button",{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                 return cancel()
             }else if (permissionMode == "everyone") return
             else if (permissionMode == "admin"){
-                if (!openticket.permissions.hasPermissions("support",await openticket.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
+                if (!opendiscord.permissions.hasPermissions("support",await opendiscord.permissions.getPermissions(instance.user,instance.channel,instance.guild))){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:["support"]}))
                     return cancel()
                 }else return
             }else{
                 if (!instance.guild || !instance.member){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #1",layout:"advanced"}))
                     return cancel()
                 }
-                const role = await openticket.client.fetchGuildRole(instance.guild,permissionMode)
+                const role = await opendiscord.client.fetchGuildRole(instance.guild,permissionMode)
                 if (!role){
                     //error
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,error:"Permission Error: Not in Server #2",layout:"advanced"}))
                     return cancel()
                 }
                 if (!role.members.has(instance.member.id)){
                     //no permissions
-                    instance.reply(await openticket.builders.messages.getSafe("openticket:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
+                    instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-no-permissions").build(source,{guild:instance.guild,channel:instance.channel,user:instance.user,permissions:[]}))
                     return cancel()
                 }else return
             }
         }),
-        new api.ODWorker("openticket:remove",0,async (instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:remove",0,async (instance,params,source,cancel) => {
             const {guild,channel,user} = instance
             if (!guild){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-not-in-guild").build("button",{channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-not-in-guild").build("button",{channel,user}))
                 return cancel()
             }
-            const ticket = openticket.tickets.get(channel.id)
+            const ticket = opendiscord.tickets.get(channel.id)
             if (!ticket || channel.isDMBased()){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-unknown").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-unknown").build("button",{guild,channel,user}))
                 return cancel()
             }
             //return when busy
-            if (ticket.get("openticket:busy").value){
+            if (ticket.get("opendiscord:busy").value){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error-ticket-busy").build("button",{guild,channel,user}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error-ticket-busy").build("button",{guild,channel,user}))
                 return cancel()
             }
 
@@ -64,19 +64,19 @@ export const registerCommandResponders = async () => {
             const reason = instance.options.getString("reason",false)
 
             //return when user is not a participant of the ticket (admins & creator can't be removed)
-            const participants = await openticket.tickets.getAllTicketParticipants(ticket)
+            const participants = await opendiscord.tickets.getAllTicketParticipants(ticket)
             if (!participants || !participants.find((p) => p.user.id == data.id && p.role == "participant")){
-                instance.reply(await openticket.builders.messages.getSafe("openticket:error").build("button",{guild,channel,user,error:openticket.languages.getTranslation("errors.actionInvalid.remove"),layout:"simple"}))
+                instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:error").build("button",{guild,channel,user,error:opendiscord.languages.getTranslation("errors.actionInvalid.remove"),layout:"simple"}))
                 return cancel()
             }
 
             //start removing user from ticket
             await instance.defer(false)
-            await openticket.actions.get("openticket:remove-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
+            await opendiscord.actions.get("opendiscord:remove-ticket-user").run(source,{guild,channel,user,ticket,reason,sendMessage:false,data})
-            await instance.reply(await openticket.builders.messages.getSafe("openticket:remove-message").build(source,{guild,channel,user,ticket,reason,data}))
+            await instance.reply(await opendiscord.builders.messages.getSafe("opendiscord:remove-message").build(source,{guild,channel,user,ticket,reason,data}))
         }),
-        new api.ODWorker("openticket:logs",-1,(instance,params,source,cancel) => {
+        new api.ODWorker("opendiscord:logs",-1,(instance,params,source,cancel) => {
-            openticket.log(instance.user.displayName+" used the 'remove' command!","info",[
+            opendiscord.log(instance.user.displayName+" used the 'remove' command!","info",[
                 {key:"user",value:instance.user.username},
                 {key:"userid",value:instance.user.id,hidden:true},
                 {key:"channelid",value:instance.channel.id,hidden:true},