#region Assembly Luminosity-API, Version=1.0.0.

0, Culture=neutral,
PublicKeyToken=null
// C:\Users\new\Desktop\New folder\LuminosityApis\bin\x64\Debug\[Link]
// Decompiled with [Link] 8.1.1.7464
#endregion

using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using DiscordRPC;
using [Link];
using [Link];
using [Link];

namespace LuminosityAPI
{
public static class LuminosityFunctions
{
public static class CoreAPI
{
public static class CoreSystem
{
public static class AutomaticallySetupFileSCore
{
public static class AutomaticallyClientInfo
{
public static class AutoIssueFalse
{
public static class FixException
{
public static class LuminosityFUNC
{
public static class External
{
public struct ClientInfo
{
public string version;
public string name;
public int id;
}

private static [Link]

time12;
private static bool isua = false;
private static bool _autoInject;
public static bool isRegistred;
public static string i;
 public static bool Isua { get => isua; set
=> isua = value; }

[DllImport("bin\\[Link]",
CallingConvention = [Link])]
private static extern void Initialize();

[DllImport("bin\\[Link]",
CallingConvention = [Link], CharSet = [Link])]
private static extern void
ExecuteAsync(byte[] scriptSource, string[] clientUsers, int numUsers);

[DllImport("bin\\[Link]",
CallingConvention = [Link])]
private static extern IntPtr GetClients();

static External()
{
time12 = new
[Link]();
Isua = false;
isRegistred = false;
i = "Axel"; // Changed name to Axel
AutoSetup();
}

public static void AutoInject(bool enable)

{
if ([Link]() &&
[Link]())
{
Initialize();
_autoInject = enable;
if (enable)
{
inject();
}
}
}

public static bool IsAutoInjectEnabled()

{
return _autoInject;
}

public static void inject()

{
if ([Link]() &&
[Link]() && isRegistred)
{
Initialize();
[Link](2000);
string s = "\
tgame:GetService(\"StarterGui\"):SetCore(\"SendNotification\", {\r\n\t\tTitle = \""
+ i + "\",\r\n\t\tText = \"Injected Successfuly!\"\r\n\t})";
string[] array = (from c in
GetClientsList()
select
[Link]).ToArray();

ExecuteAsync([Link](s), array, [Link]);

}
}

public static void execute(string

scriptSource)
{
string[] array = (from c in
GetClientsList()
select
[Link]).ToArray();

ExecuteAsync([Link](scriptSource), array, [Link]);

}

public static List<ClientInfo>

GetClientsList()
{
List<ClientInfo> list = new
List<ClientInfo>();
IntPtr clients = GetClients();
while (true)
{
ClientInfo item =
[Link]<ClientInfo>(clients);
if ([Link] != null)
{
[Link](item);
clients +=
[Link]<ClientInfo>();
continue;
}
break;
}
return list;
}

public static void RegisterExecutor(string

injectionMessage)
{
i = injectionMessage;
isRegistred = true;
}

public static bool IsInjected()

{
try
{
return GetClientsList().Count > 0;
}
catch
{
return false;
}
}

private static void AutoSetup()

 {
string[] array = new string[5]
{ "[Link]", "[Link]", "[Link]", "[Link]", "[Link]"
};
string text =
[Link]([Link], "bin");
if ()
{
[Link](text);
}

foreach (string text2 in array)

{
string text3 = [Link](text,
text2);
if ()
{
try
{
string address =
"[Link] + text2;
using (WebClient webClient
= new WebClient())
{

[Link](address, text3);
}
}
catch (Exception ex)
{
[Link]("Failed to
Download " + text2 + ": " + [Link], "LuminosityApi");
}
}
}
}
}

public static class Internal

{
static Internal()
{
AutoSetup();
[Link](delegate
{
CleanRobloxVersions();
});
CreateCLDYWorkspace();
[Link] =
[Link]([Link]([Link]
ta), "[Link]");
[Link]();
}

private static void CleanRobloxVersions()

{
string folderPath =
[Link]([Link]);
string path = [Link](folderPath,
"Roblox", "Versions");
if ()
{
return;
}

string[] array = new string[5]

{ "msvcp140_1.dll", "msvcp140_2.dll", "[Link]", "[Link]",
"vcruntime140_1.dll" };
try
{
string[] directories =
[Link](path, "version-*");
foreach (string path2 in
directories)
{
foreach (string path3 in array)
{
string path4 =
[Link](path2, path3);
if ([Link](path4))
{
try
{
[Link](path4);
}
catch { }
}
}
}
}
catch { }
}

public static void CreateCLDYWorkspace()

{
string localAppData =
[Link]([Link]);
string targetPath =
[Link](localAppData, "CLDY", "Workspace");
if ()
{

[Link](targetPath);
}
}

public static void inject()

{
try
{
Process process = new Process
{
StartInfo =
{
FileName = "[Link]",
UseShellExecute = false,
CreateNoWindow = true
}
 };
[Link]();
}
catch (Exception ex)
{
[Link]("Error starting
injector: " + [Link], "Error", [Link], [Link]);
}
}

public static void execute(string script)

{
try
{
string directoryName =
[Link]([Link]);
if (!
[Link](directoryName))
{

[Link](directoryName);
}
[Link]([Link],
script);
}
catch (Exception) { }
}

private static void AutoSetup()

{
string[] array = new string[2]
{ "[Link]", "[Link]" };
string[] array2 = new string[2]
{ "[Link]", "[Link]" };
string baseDirectory =
[Link];
if ()
{

[Link](baseDirectory);
}

for (int i = 0; i < [Link]; i++)

{
string text = array[i];
string path = array2[i];
string text2 =
[Link](baseDirectory, path);
if ()
{
try
{
string address =
"[Link] + text;
using (WebClient webClient
= new WebClient())
{

[Link](address, text2);
 }
}
catch (Exception ex)
{
[Link]("An error
occurred while downloading required files. ERR: " + [Link]);
}
}
}
}

private class Configs

{
internal static string executeP;

internal static void SetupFileWatcher()

{
FileSystemWatcher watcher = new
FileSystemWatcher
{
Path =
[Link](executeP),
Filter =
[Link](executeP),
EnableRaisingEvents = true
};
[Link] += OnFileChanged;
}

private static void

OnFileChanged(object sender, FileSystemEventArgs e)
{
// Handle file change event here
}
}
}

public static class misc

{
public static string editorUri;
private static readonly HttpClient client;
private static DiscordRpcClient clients;
private static DiscordRpcClient clientas;

static misc()
{
editorUri =
"[Link]
client = new HttpClient();
AutoSetup();

[Link]("Authorization", "v1USERFREE");
}

public static void disableSecurity()

{
[Link] = false;
}
 public static void credits()
{
[Link]("This api was made by
@PolarBear. Thanks to @Bomaymup for contributing to the internal module!",
"LuminosityApi");
}

private static string

GetUserIdFromUsername(string username)
{
string address =
"[Link]
string data = "{\"usernames\": [\"" +
username + "\"]}";
try
{
using (WebClient webClient = new
WebClient())
{

[Link][[Link]] = "application/json";
string text =
[Link](address, "POST", data);
JObject json =
[Link](text);
if (json["data"] != null &&
json["data"].HasValues)
{
return json["data"][0]
["id"]?.ToString();
}
}
}
catch (Exception ex)
{
[Link]("Error getting user
ID for " + username + ": " + [Link], "LuminosityApi");
}
return null;
}

public static BitmapImage GetAvatar(string

username)
{
string userIdFromUsername =
GetUserIdFromUsername(username);
if
([Link](userIdFromUsername))
{
return null;
}

string address =
"[Link] +
userIdFromUsername + "&size=420x420&format=png";
try
{
using (WebClient webClient = new
WebClient())
 {
string text =
[Link](address);
JObject json =
[Link](text);
if (json["data"] != null &&
json["data"].HasValues)
{
string uriString =
json["data"][0]["imageUrl"]?.ToString();
return new BitmapImage(new
Uri(uriString));
}
}
}
catch (Exception ex)
{
[Link]("Error getting
avatar for " + username + ": " + [Link], "LuminosityApi");
}
return null;
}

public static string SetScriptJS(string

script)
{
return "setText(\"" +
[Link](script) + "\")";
}

public static string GetTextJS()

{
return "getText()";
}

public static string AddTabJS(string name,

string content)
{
return "addTab(\"" +
[Link](name) + "\", \"" +
[Link](content) + "\")";
}

public static bool isRobloxOpen()

{
return
[Link]("RobloxPlayerBeta").Any();
}

public static void SetDiscordRpc(string

title, string appid, string img, string state)
{
clients = new DiscordRpcClient(appid);
[Link] += (sender, e) => { };
[Link]();
[Link](new RichPresence
{
Details = title,
State = state,
 Timestamps = [Link],
Assets = new Assets
{
LargeImageKey = img,
LargeImageText = title
}
});
}

[Obsolete]
public static async Task<string>
GetDiscordUsername(string appId)
{
TaskCompletionSource<string> tcs = new
TaskCompletionSource<string>();
clientas = new DiscordRpcClient(appId);
[Link] += (sender, e) =>
{
string result =
$"{[Link]}#{[Link]}";
[Link](result);
};
[Link]();
[Link](new RichPresence
{
Details = "Username Validation...",
State = "Please wait",
Timestamps = [Link]
});
return await [Link];
}

public static bool CheckRobloxVersion()

{
Process[] processesByName =
[Link]("RobloxPlayerBeta");
if ([Link] == 0)
{
[Link]("Roblox is not
running.", "LuminosityApi");
return false;
}

string fileName =
processesByName[0].[Link];
string name = new
DirectoryInfo([Link](fileName)).Name;
if (name !=
[Link])
{
if (![Link])
{
return true;
}
[Link]("LuminosityApi is
Outdated. Please Update The Newest Version!", "LuminosityApi");
return false;
}
return true;
 }

public static string GetUsername()

{
string userName = [Link];
string path = "C:\\\\Users\\\\" +
userName + "\\\\AppData\\\\Local\\\\Roblox\\\\LocalStorage\\\\[Link]";
if ()
{
return null;
}

try
{
string text =
[Link](path);
JObject json = [Link](text);
if ([Link]("Username"))
{
return
json["Username"]?.ToString();
}
}
catch (Exception ex)
{
[Link]("Error getting
username " + [Link], "LuminosityApi");
}
return null;
}

public static void killRoblox()

{
Process[] processesByName =
[Link]("RobloxPlayerBeta");
foreach (Process process in
processesByName)
{
try
{
[Link]();
[Link]();
}
catch (Exception ex)
{
[Link]("Failed to
kill process: " + [Link]);
}
}
}

public static async Task<string>

AskAi(string input)
{
try
{
using (StringContent reqbody = new
StringContent("{\"input\":\"" + input + "\"}", Encoding.UTF8, "application/json"))
{
 HttpResponseMessage response =
await [Link]("[Link] reqbody);
if
([Link])
{
string responseContent =
await [Link]();
JObject json =
[Link](responseContent);
return
json["response"]?.ToString() ?? "AI is currently not available: 'AI WAS DISABLED BY
ADMINISTRATOR'";
}
return "Error: No valid
response";
}
}
catch (Exception ex)
{
return "Error: " + [Link];
}
}

public static string Cleanres(string res)

{
return [Link](res, "^```lua\\
s*(.*?)\\s*```$", "$1", [Link]);
}

private static void AutoSetup()

{
string[] array = new string[2]
{ "[Link]", "[Link]" };
string text =
[Link]([Link]);
if ()
{
[Link](text);
}

foreach (string text2 in array)

{
string text3 = [Link](text,
text2);
if ()
{
try
{
string address =
"[Link] + text2;
using (WebClient webClient
= new WebClient())
{

[Link](address, text3);
}
}
catch (Exception ex)
{
 [Link]("Failed to
Download " + text2 + ": " + [Link], "LuminosityApi");
}
}
}
}

public static string cPlaceId()

{
try
{
string path =
[Link]([Link]([Link]
ta), "Roblox", "logs");
List<string> source = (from f in
[Link](path, "*.log")
orderby new
FileInfo(f).LastWriteTime descending, new FileInfo(f).Length descending
select
f).ToList();
Regex regex = new
Regex("placeIds=(\\d+)", [Link]);
Regex regex2 = new Regex("placeid:
(\\d+)", [Link]);
foreach (string item in
[Link](5))
{
using (FileStream stream = new
FileStream(item, [Link], [Link], [Link]))
using (StreamReader
streamReader = new StreamReader(stream))
{
string text = null;
string input;
while ((input =
[Link]()) != null)
{
Match match =
[Link](input);
if ([Link])
{
text =
[Link][1].Value;
}

Match match2 =
[Link](input);
if ([Link])
{
text =
[Link][1].Value;
}
}

if (!
[Link](text))
{
return text;
}
 }
}
return null;
}
catch (Exception ex)
{
return "Error: " + [Link];
}
}

public static async Task<string>

cPlaceName(string placeId)
{
try
{
using (HttpClient httpClient = new
HttpClient())
{
string url =
"[Link] + placeId;
HttpResponseMessage response =
await [Link](url);
if (!
[Link])
{
return $"Failed to retrieve
data: {[Link]}";
}

string content = await

[Link]();
Match titleMatch =
[Link](content, "<title>(.+?) - Roblox</title>", [Link]);
if ([Link])
{
return
[Link][1].[Link]();
}
return "Place name not found in
page content.";
}
}
catch (Exception ex)
{
return "Error: " + [Link];
}
}

public static async Task<string>

cPlaceImage(string placeId)
{
try
{
using (HttpClient httpClient = new
HttpClient())
{
string url =
"[Link] + placeId +
"&format=Png&size=768x432";
 HttpResponseMessage response =
await [Link](url);
if (!
[Link])
{
return $"Failed to retrieve
image: {[Link]}";
}

string content = await

[Link]();
Match match =
[Link](content, "\"imageUrl\":\\s*\"(https:[^\"]+)\"");
if ([Link])
{
return
[Link][1].Value;
}
return "Image URL not found.";
}
}
catch (Exception ex)
{
return "Error: " + [Link];
}
}
}
}

internal class Configs

{
internal static bool isSec;
internal static string SupportedRobloxVersion =
null;
}
}
}
}
}
}
}
}
}