return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    assert(type(v0) == "string", "SetGamePrivateServersEnabled: universeId must be a string");
    assert(type(v1) == "boolean", "SetGamePrivateServersEnabled: isFavorited must be a boolean");
    return {
        universeId = v0,
        privateServersEnabled = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    assert(type(v0) == "string", string.format("SetGameSocialLinks action expects universeId to be a string, was %s", (type(v0))));
    assert(type(v1) == "table", string.format("SetGameSocialLinks action expects socialLinks to be a table, was %s", (type(v1))));
    return {
        universeId = v0,
        socialLinks = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        sortName = v0,
        status = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        sortCategory = v0,
        fetchStatus = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1, v2, v3)
    return {
        groupId = v0,
        sorts = v1,
        pageId = v2,
        sortsTopicLayoutData = v3
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        sortCategory = v0,
        nextRefreshTime = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        contentIds = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        pageType = v0,
        refreshTime = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        pageType = v0,
        status = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        universeId = v0,
        entries = v1
    };
end);


return require(game:GetService("CoreGui"):FindFirstChild("RobloxGui").Modules.Common.Action)("UpdateGameMedia", function(v0, v1)
    return {
        universeId = v0,
        entries = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        focusController = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        moderationDetail = v0
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local l_CorePackages_0 = game:GetService("CorePackages");
local v2 = require(l_Modules_0.Common.Action);
local v3 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
return v2(script.Name, function(v4)
    v3.isType(v4, "boolean", "SetModerationStatus action expects `modStatus` to be a boolean");
    return {
        userModerated = v4
    };
end);


local v0 = require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action);
local v1 = {
    "%s(www%.[^%s]+)",
    "%shttps?://([^%s]+)"
};
return v0(script.Name, function(v2)
    assert(type(v2) == "table", string.format("UpdateSiteMessageBannerText action expects data to be a table, was %s", (type(v2))));
    local v3;
    v3 = v2.LinkUrl and (#v3 == 0 and nil);
    if not (not v2.Text or v3) then
        for _, v5 in ipairs(v1) do
            local v6, _, v8 = string.find(v2.Text, v5);
            if v6 then
                v3 = "https://" .. v8;
            end;
        end;
    end;
    return {
        text = v2.Text,
        visible = v2.IsVisible or false,
        link = v3,
        timestamp = v2.timestamp or nil
    };
end);


local v0 = require(game:GetService("CorePackages").Cryo);
return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v1)
    return v0.Dictionary.join({
        updateRequested = true
    }, v1 or {});
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        searchUuid = v0
    };
end);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_makeActionCreator_0 = require(l_CorePackages_0.Rodux).makeActionCreator;
local v2 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
return l_makeActionCreator_0(script.Name, function(v3)
    v2.isType(v3, "string", "Actions.RemoveUsersSearchResults.keyword");
    return {
        keyword = v3
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        userId = v0
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isNonNegativeNumber(v3, "SetAccountNotificationCount: accountNotificationCount");
    return {
        accountNotificationCount = v3
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        universeId = v0,
        ageRecommendationDetails = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        universeId = v0,
        containsStrongLanguage = v1
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    return {
        disabled = v2.isType(v3, "boolean", "disabled")
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        boundInputs = v0,
        focusController = v1
    };
end);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_makeActionCreator_0 = require(l_CorePackages_0.Rodux).makeActionCreator;
local v2 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
return l_makeActionCreator_0(script.Name, function(v3)
    v2.isType(v3, "string", "searchType");
    return {
        searchType = v3
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isType(v3, "table", "SetDevSub: devSub");
    return {
        devSub = v3
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isType(v3, "table", "SetDevSubs: devSubs");
    return {
        devSubs = v3
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isNonNegativeNumber(v3, "SetEmailNotificationCount: count");
    return {
        count = v3
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    assert(type(v0) == "string", string.format("SetFetchHomePageDataStatusAll action expects status to be an string, was %s", (type(v0))));
    return {
        status = v0
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isNonNegativeNumber(v3, "SetFriendRequestsCount: count");
    return {
        count = v3
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3, v4)
    v2.isType(v3, "string", "universeId");
    v2.isType(v4, "table", "badges");
    return {
        universeId = v3,
        badges = v4
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    assert(type(v0) == "string", "SetGameFollow: universeId must be a string");
    assert(type(v1) == "boolean", "SetGameFollow: isFollowed must be a boolean");
    return {
        universeId = v0,
        isFollowed = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1, v2)
    assert(type(v0) == "string", "SetGameFollowingStatus: universeId must be a string");
    assert(type(v1) == "boolean", "SetGameFollowingStatus: canFollow must be a boolean");
    assert(type(v2) == "boolean", "SetGameFollowingStatus: isFollowed must be a boolean");
    return {
        universeId = v0,
        canFollow = v1,
        isFollowed = v2
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3, v4)
    v2.isType(v3, "string", "universeId");
    v2.isType(v4, "boolean", "isUniverseEnabledForVoice");
    return {
        universeId = v3,
        isUniverseEnabledForVoice = v4
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3, v4, v5, v6)
    v2.isNonNegativeNumber(v3, "SetGlobalContextMenuInset: left");
    v2.isNonNegativeNumber(v4, "SetGlobalContextMenuInset: top");
    v2.isNonNegativeNumber(v5, "SetGlobalContextMenuInset: right");
    v2.isNonNegativeNumber(v6, "SetGlobalContextMenuInset: bottom");
    return {
        left = v3,
        top = v4,
        right = v5,
        bottom = v6
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3, v4, v5, v6)
    v2.isNonNegativeNumber(v3, "SetGlobalGuiInset: left");
    v2.isNonNegativeNumber(v4, "SetGlobalGuiInset: top");
    v2.isNonNegativeNumber(v5, "SetGlobalGuiInset: right");
    v2.isNonNegativeNumber(v6, "SetGlobalGuiInset: bottom");
    return {
        left = v3,
        top = v4,
        right = v5,
        bottom = v6
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    assert(type(v0) == "string", string.format("SetHomePageDataStatus action expects status to be an string, was %s", (type(v0))));
    return {
        status = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1, v2)
    return {
        upsellCardType = v0,
        titleTextOverride = v1,
        bodyTextOverride = v2
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.LuaApp.ArgCheck);
return require(l_Modules_0.Common.Action)(script.Name, function(v2, v3, v4)
    v1.isType(v2, "table", "SetIAPProducts: robuxProducts");
    v1.isType(v3, "table", "SetIAPProducts: robuxPremiumProducts");
    v1.isType(v4, "table", "SetIAPProducts: subscriptionProducts");
    return {
        robux = v2,
        premiumRobux = v3,
        subscriptions = v4
    };
end);


return require(game:GetService("CorePackages").Packages.Rodux).makeActionCreator(script.Name, function(v0)
    return {
        isSoothsayer = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        isUnder13 = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        nativeLocaleName = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        nativeProductId = v0,
        purchaseStatus = v1
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.LuaApp.ArgCheck);
return require(l_Modules_0.Common.Action)(script.Name, function(v2)
    v1.isType(v2, "table", "SetNativeRobuxProducts: nativeRobuxProducts");
    return {
        nativeRobuxProducts = v2
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isNonNegativeNumber(v3, "SetNotificationCount: notificationCount");
    return {
        notificationCount = v3
    };
end);


return require(game:GetService("CorePackages").Rodux).makeActionCreator(script.Name, function(v0)
    return {
        passesThumbnails = v0
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isNonNegativeNumber(v3, "SetPasswordNotificationCount: count");
    return {
        count = v3
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        platform = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        isPreloading = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1, v2)
    return {
        source = v0,
        blur = v1,
        displayOrder = v2
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        screenSize = v0
    };
end);


return require(game:GetService("CorePackages").Rodux).makeActionCreator("SetSearchBarFocused", function(v0)
    return {
        focused = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        searchUuid = v0,
        status = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        searchUuid = v0,
        parameters = v1
    };
end);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v2 = require(l_CorePackages_0.Rodux);
local v3 = require(l_Modules_0.LuaApp.ArgCheck);
return v2.makeActionCreator(script.Name, function(v4, v5)
    v3.isNonEmptyString(v4, "SetSearchTime: searchUuid");
    v3.isNonNegativeNumber(v5, "SetSearchTime: searchTime");
    return {
        searchUuid = v4,
        searchTime = v5
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    return {
        searchUuid = v0,
        searchType = v1
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        statusBarHeight = v0
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0)
    return {
        topBarHeight = v0
    };
end);


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.Common.Action);
local v2 = require(l_Modules_0.LuaApp.ArgCheck);
return v1(script.Name, function(v3)
    v2.isNonNegativeNumber(v3, "SetUnreadMessageCount: count");
    return {
        count = v3
    };
end);


return require(game:GetService("CoreGui").RobloxGui.Modules.Common.Action)(script.Name, function(v0, v1)
    assert(type(v0) == "string", "SetUserRobux: universeId must be a string");
    assert(type(v1) == "number", "SetUserRobux: robux must be a number");
    return {
        userId = v0,
        robux = v1
    };
end);


return {
    Success = "AppLogin-Success",
    Failure = "AppLogin-Failure",
    FailureAuthCode = "AppLogin-AuthCode-Failure",
    FailureTimeout = "AppLogin-Failure-0-Timeout",
    FailureBadRequest = "AppLogin-Failure-400-BadRequest",
    FailureTwoStepVerification = "AppLogin-Failure-403-TwoStepVerification",
    FailureCredentials = "AppLogin-Failure-403-Credentials",
    FailureCaptcha = "AppLogin-Failure-403-Captcha",
    FailurePasswordReset = "AppLogin-Failure-403-PasswordReset",
    FailureNotFound = "AppLogin-Failure-404-NotFound",
    FailureThrottled = "AppLogin-Failure-429-Throttled",
    FailureInternalServerError = "AppLogin-Failure-500-InternalServerError",
    FailureUnknownError = "AppLogin-Failure-UnknownError",
    FailureSecurityQuestions = "AppLogin-403-SecurityQuestions",
    FailureMultipleUsersPerCredential = "AppLogin-403-MultipleUsersPerCredential"
};


return {
    Success = "SessionCheck-Success",
    Failure = "SessionCheck-Failure",
    Failure401Unauthenticated = "SessionCheck-Failure-401-Unauthenticated",
    FailureUnknownError = "SessionCheck-Failure-UnknownError",
    AccountInfoUnknownError = "SessionCheck-Users-Account-Info-Error-Unknown",
    AccountInfoErrorUnauthorized = "SessionCheck-Users-Account-Info-Error-Unauthorized",
    UsersAuthenticatedUnknownError = "SessionCheck-Users-Authenticated-Error-Unknown",
    UsersAuthenticatedErrorUnauthorized = "SessionCheck-Users-Authenticated-Error-Unauthorized"
};


return {
    Success = "AppSignup-Success",
    Failure = "AppSignup-Failure",
    FailureBadRequest = "AppSignup-Failure-400-BadRequest",
    FailureTokenValidationFailed = "AppSignup-Failure-403-TokenValidationFailed",
    FailureBirthdayInvalid = "AppSignup-Failure-403-BirthdayInvalid",
    FailurePasswordInvalid = "AppSignup-Failure-403-PasswordInvalid",
    FailureUsernameInvalid = "AppSignup-Failure-403-UsernameInvalid",
    FailureUsernameTaken = "AppSignup-Failure-403-UsernameTaken",
    FailureCaptcha = "AppSignup-Failure-403-Captcha",
    FailurePasswordMatchesUsername = "AppSignup-Failure-403-PasswordMatchesUsername",
    FailurePasswordTooSimple = "AppSignup-Failure-403-PasswordTooSimple",
    FailureBundleIdNotValid = "AppSignup-Failure-403-BundleIdNotValid",
    FailureNotFound = "AppSignup-Failure-404-NotFound",
    FailureThrottled = "AppSignup-Failure-429-Throttled",
    FailureInternalServerError = "AppSignup-Failure-500-InternalServerError",
    FailureUnknownError = "AppSignup-Failure-UnknownError"
};


local v0 = require(game:GetService("CorePackages").Logging);
return function(v1, v2, v3, v4, v5, v6)
    local v7 = {};
    if v3 then
        if type(v3) ~= "string" then
            v0.warn("Failure logging authButtonClick: Expected btn to be a string but got " .. type(v3));
            return ;
        else
            v7.btn = v3;
        end;
    end;
    if v4 then
        if type(v4) ~= "string" then
            v0.warn("Failure logging authButtonClick: Expected state to be a string but got " .. type(v4));
            return ;
        else
            v7.state = v4;
        end;
    end;
    if v5 then
        if type(v5) ~= "string" then
            v0.warn("Failure logging authButtonClick: Expected url to be a string but got " .. type(v5));
            return ;
        else
            v7.url = v5;
        end;
    end;
    if v6 ~= nil then
        if type(v6) ~= "boolean" then
            v0.warn("Failure logging authPageLoad: Expected isAltAttempt to be a boolean but got " .. type(v6));
            return ;
        else
            v7.is_alt_attempt = v6;
        end;
    end;
    v1:setRBXEventStream(v2, "authButtonClick", v7);
end;


local v0 = require(game:GetService("CorePackages").Logging);
return function(v1, v2, v3)
    local v4 = {};
    if v3 then
        if type(v3) ~= "string" then
            v0.warn("Failure logging authClientError: Expected state to be a string but got " .. type(v3));
            return ;
        else
            v4.state = v3;
        end;
    end;
    v1:setRBXEventStream(v2, "authClientError", v4);
end;


local v0 = require(game:GetService("CorePackages").Logging);
return function(v1, v2, v3, v4, v5, v6)
    local v7 = {};
    if v3 then
        if type(v3) ~= "string" then
            v0.warn("Failure logging authFormInteraction: Expected field to be a string but got " .. type(v3));
            return ;
        else
            v7.field = v3;
        end;
    end;
    if v4 then
        if type(v4) ~= "string" then
            v0.warn("Failure logging authFormInteraction: Expected state to be a string but got " .. type(v4));
            return ;
        else
            v7.state = v4;
        end;
    end;
    if v5 then
        if type(v5) ~= "string" then
            v0.warn("Failure logging authFormInteraction: Expected origin to be a string but got " .. type(v5));
            return ;
        else
            v7.origin = v5;
        end;
    end;
    if v6 then
        if type(v6) ~= "string" then
            v0.warn("Failure logging authFormInteraction: Expected entered to be a string but got " .. type(v6));
            return ;
        else
            v7.entered = v6;
        end;
    end;
    v1:setRBXEventStream(v2, "authFormInteraction", v7);
end;


local v0 = require(game:GetService("CorePackages").Logging);
return function(v1, v2, v3)
    local v4 = {};
    if v3 then
        if type(v3) ~= "string" then
            v0.warn("Failure logging authModalShown: Expected state to be a string but got " .. type(v3));
            return ;
        else
            v4.state = v3;
        end;
    end;
    v1:setRBXEventStream(v2, "authModalShown", v4);
end;


local v0 = require(game:GetService("CorePackages").Logging);
return function(v1, v2, v3, v4)
    local v5 = {};
    if v3 then
        if type(v3) ~= "string" then
            v0.warn("Failure logging authPageLoad: Expected state to be a string but got " .. type(v3));
            return ;
        else
            v5.state = v3;
        end;
    end;
    if v4 ~= nil then
        if type(v4) ~= "boolean" then
            v0.warn("Failure logging authPageLoad: Expected isAltAttempt to be a boolean but got " .. type(v4));
            return ;
        else
            v5.is_alt_attempt = v4;
        end;
    end;
    v1:setRBXEventStream(v2, "authPageload", v5);
end;


return function(v0, v1, v2, v3, v4)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected buttonName to be a string");
    assert(type(v4) == "string", "Expected ctype to be a string");
    local v5 = {
        btn = v2,
        ctype = v4
    };
    if v3 ~= nil then
        assert(type(v3) == "string", "Expected extraData to be a string");
        v5.cstm = v3;
    end;
    v0:setRBXEventStream(v1, "buttonClick", v5);
end;


return function(v0, v1, v2, v3, v4, v5)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected buttonName to be a string");
    local v6 = {
        btn = v2,
        section = v4,
        origin = v5
    };
    if v3 ~= nil then
        assert(type(v3) == "string", "Expected extraData to be a string");
        v6.cstm = v3;
    end;
    v0:setRBXEventStream(v1, "buttonClick", v6);
end;


return function(v0, v1, v2, v3, v4, v5, v6)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected field to be a string");
    assert(type(v3) == "string", "Expected actionType to be a string");
    if v4 ~= nil then
        assert(type(v4) == "string", "Expected origin to be a string");
    end;
    if v5 ~= nil then
        assert(type(v5) == "string", "Expected btn to be a string");
    end;
    v0:setRBXEventStream(v1, "formInteraction", {
        field = v2,
        aType = v3,
        origin = v4,
        btn = v5,
        section = v6
    });
end;


return function(v0, v1, v2, v3, v4, v5, v6)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v3) == "string", "Expected actionType to be a string");
    v0:setRBXEventStream(v1, "modalAction", {
        aType = v3,
        origin = v4,
        section = v5,
        errorCode = v6,
        field = v2
    });
end;


return function(v0, v1, v2, v3, v4)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected state to be a string");
    assert(type(v3) == "table", "Expected suggestions to be a table");
    assert(type(v4) == "string", "Expected suggestion to be a string");
    v0:sendEventDeferred(v1, "usernameSuggestionShown", {
        state = v2,
        suggestions = ("[%*]"):format((table.concat(v3, ","))),
        field = v4
    });
end;


local v0 = require(game:GetService("CoreGui").RobloxGui.Modules.Common.Immutable);
local l_Players_0 = game:GetService("Players");
local function _(v2)
    return function(v3, v4, v5, v6)
        assert(type(v4) == "string", "Expected eventContext to be a string");
        assert(type(v5) == "string", "Expected placeId to be a string");
        assert(type(v6) == "table", "Expected state to be a table");
        v3:setRBXEventStream(v4, v2, (v0.JoinDictionaries({
            uid = tostring(l_Players_0.LocalPlayer.UserId),
            placeId = v5
        }, v6)));
    end;
end;
local function _(v8)
    local function v13(v9, v10, v11, v12)
        assert(type(v10) == "string", "Expected eventContext to be a string");
        assert(type(v11) == "string", "Expected placeId to be a string");
        assert(type(v12) == "table", "Expected state to be a table");
        v9:setRBXEventStream(v10, v8, (v0.JoinDictionaries({
            uid = tostring(l_Players_0.LocalPlayer.UserId),
            placeId = v11
        }, v12)));
    end;
    return function(v14, v15, v16, v17, v18)
        assert(type(v17) == "boolean", "Expected state to be a boolean");
        if v18 ~= nil then
            assert(type(v18) == "table", "Expected extraData to be a table");
        end;
        return v13(v14, v15, v16, (v0.JoinDictionaries(v18 or {}, {
            state = not v17 and "off" or "on"
        })));
    end;
end;
local function _(v20)
    local function v25(v21, v22, v23, v24)
        assert(type(v22) == "string", "Expected eventContext to be a string");
        assert(type(v23) == "string", "Expected placeId to be a string");
        assert(type(v24) == "table", "Expected state to be a table");
        v21:setRBXEventStream(v22, v20, (v0.JoinDictionaries({
            uid = tostring(l_Players_0.LocalPlayer.UserId),
            placeId = v23
        }, v24)));
    end;
    return function(v26, v27, v28, v29)
        return v25(v26, v27, v28, v29 or {});
    end;
end;
local v31 = {};
local v32 = "copyExperienceLink";
local l_v32_0 = v32 --[[ copy: 9 -> 10 ]];
local function v38(v34, v35, v36, v37)
    assert(type(v35) == "string", "Expected eventContext to be a string");
    assert(type(v36) == "string", "Expected placeId to be a string");
    assert(type(v37) == "table", "Expected state to be a table");
    v34:setRBXEventStream(v35, l_v32_0, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v36
    }, v37)));
end;
local l_v38_0 = v38 --[[ copy: 8 -> 11 ]];
v31.CopyExperienceLink = function(v40, v41, v42, v43)
    return l_v38_0(v40, v41, v42, v43 or {});
end;
v32 = "favorite";
local l_v32_1 = v32 --[[ copy: 9 -> 12 ]];
v38 = function(v45, v46, v47, v48)
    assert(type(v46) == "string", "Expected eventContext to be a string");
    assert(type(v47) == "string", "Expected placeId to be a string");
    assert(type(v48) == "table", "Expected state to be a table");
    v45:setRBXEventStream(v46, l_v32_1, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v47
    }, v48)));
end;
local l_v38_1 = v38 --[[ copy: 8 -> 13 ]];
v31.Favorite = function(v50, v51, v52, v53, v54)
    assert(type(v53) == "boolean", "Expected state to be a boolean");
    if v54 ~= nil then
        assert(type(v54) == "table", "Expected extraData to be a table");
    end;
    return l_v38_1(v50, v51, v52, (v0.JoinDictionaries(v54 or {}, {
        state = not v53 and "off" or "on"
    })));
end;
v32 = "follow";
local l_v32_2 = v32 --[[ copy: 9 -> 14 ]];
v38 = function(v56, v57, v58, v59)
    assert(type(v57) == "string", "Expected eventContext to be a string");
    assert(type(v58) == "string", "Expected placeId to be a string");
    assert(type(v59) == "table", "Expected state to be a table");
    v56:setRBXEventStream(v57, l_v32_2, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v58
    }, v59)));
end;
local l_v38_2 = v38 --[[ copy: 8 -> 15 ]];
v31.Follow = function(v61, v62, v63, v64, v65)
    assert(type(v64) == "boolean", "Expected state to be a boolean");
    if v65 ~= nil then
        assert(type(v65) == "table", "Expected extraData to be a table");
    end;
    return l_v38_2(v61, v62, v63, (v0.JoinDictionaries(v65 or {}, {
        state = not v64 and "off" or "on"
    })));
end;
v32 = "navigateToInviteFriends";
local l_v32_3 = v32 --[[ copy: 9 -> 16 ]];
v38 = function(v67, v68, v69, v70)
    assert(type(v68) == "string", "Expected eventContext to be a string");
    assert(type(v69) == "string", "Expected placeId to be a string");
    assert(type(v70) == "table", "Expected state to be a table");
    v67:setRBXEventStream(v68, l_v32_3, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v69
    }, v70)));
end;
local l_v38_3 = v38 --[[ copy: 8 -> 17 ]];
v31.ShareGameToChat = function(v72, v73, v74, v75)
    return l_v38_3(v72, v73, v74, v75 or {});
end;
v31.GameDetailsSubpage = function(v76, v77, v78, v79)
    local v80 = "gameDetailsSubpage";
    (function(v81, v82, v83, v84)
        assert(type(v82) == "string", "Expected eventContext to be a string");
        assert(type(v83) == "string", "Expected placeId to be a string");
        assert(type(v84) == "table", "Expected state to be a table");
        v81:setRBXEventStream(v82, v80, (v0.JoinDictionaries({
            uid = tostring(l_Players_0.LocalPlayer.UserId),
            placeId = v83
        }, v84)));
    end)(v76, v77, v78, {
        subpage = v79
    });
end;
v31.Vote = function(v85, v86, v87, v88, v89)
    local v90 = "vote";
    (function(v91, v92, v93, v94)
        assert(type(v92) == "string", "Expected eventContext to be a string");
        assert(type(v93) == "string", "Expected placeId to be a string");
        assert(type(v94) == "table", "Expected state to be a table");
        v91:setRBXEventStream(v92, v90, (v0.JoinDictionaries({
            uid = tostring(l_Players_0.LocalPlayer.UserId),
            placeId = v93
        }, v94)));
    end)(v85, v86, v87, {
        vote = v88,
        prevVote = v89
    });
end;
v32 = "openMore";
local l_v32_4 = v32 --[[ copy: 9 -> 18 ]];
v38 = function(v96, v97, v98, v99)
    assert(type(v97) == "string", "Expected eventContext to be a string");
    assert(type(v98) == "string", "Expected placeId to be a string");
    assert(type(v99) == "table", "Expected state to be a table");
    v96:setRBXEventStream(v97, l_v32_4, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v98
    }, v99)));
end;
local l_v38_4 = v38 --[[ copy: 8 -> 19 ]];
v31.OpenMore = function(v101, v102, v103, v104)
    return l_v38_4(v101, v102, v103, v104 or {});
end;
v32 = "openGameDetailsPT";
local l_v32_5 = v32 --[[ copy: 9 -> 20 ]];
v38 = function(v106, v107, v108, v109)
    assert(type(v107) == "string", "Expected eventContext to be a string");
    assert(type(v108) == "string", "Expected placeId to be a string");
    assert(type(v109) == "table", "Expected state to be a table");
    v106:setRBXEventStream(v107, l_v32_5, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v108
    }, v109)));
end;
local l_v38_5 = v38 --[[ copy: 8 -> 21 ]];
v31.OpenPlayTogether = function(v111, v112, v113, v114)
    return l_v38_5(v111, v112, v113, v114 or {});
end;
v32 = "createPrivateGame";
local l_v32_6 = v32 --[[ copy: 9 -> 22 ]];
v38 = function(v116, v117, v118, v119)
    assert(type(v117) == "string", "Expected eventContext to be a string");
    assert(type(v118) == "string", "Expected placeId to be a string");
    assert(type(v119) == "table", "Expected state to be a table");
    v116:setRBXEventStream(v117, l_v32_6, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v118
    }, v119)));
end;
local l_v38_6 = v38 --[[ copy: 8 -> 23 ]];
v31.CreatePrivateGame = function(v121, v122, v123, v124)
    return l_v38_6(v121, v122, v123, v124 or {});
end;
v32 = "joinFriendsInGame";
local l_v32_7 = v32 --[[ copy: 9 -> 24 ]];
v38 = function(v126, v127, v128, v129)
    assert(type(v127) == "string", "Expected eventContext to be a string");
    assert(type(v128) == "string", "Expected placeId to be a string");
    assert(type(v129) == "table", "Expected state to be a table");
    v126:setRBXEventStream(v127, l_v32_7, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v128
    }, v129)));
end;
local l_v38_7 = v38 --[[ copy: 8 -> 25 ]];
v31.JoinFriendsInGame = function(v131, v132, v133, v134)
    return l_v38_7(v131, v132, v133, v134 or {});
end;
v32 = "shareExperienceLink";
v38 = function(v135, v136, v137, v138)
    assert(type(v136) == "string", "Expected eventContext to be a string");
    assert(type(v137) == "string", "Expected placeId to be a string");
    assert(type(v138) == "table", "Expected state to be a table");
    v135:setRBXEventStream(v136, v32, (v0.JoinDictionaries({
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        placeId = v137
    }, v138)));
end;
v31.ShareExperienceLink = function(v139, v140, v141, v142)
    return v38(v139, v140, v141, v142 or {});
end;
return v31;


local l_Players_0 = game:GetService("Players");
local l_LocalizationService_0 = game:GetService("LocalizationService");
local v2 = require(game:GetService("CoreGui").RobloxGui.Modules.LuaApp.ArgCheck);
return function(v3, v4, v5, v6, v7)
    v2.isType(v4, "string", "eventName");
    v2.isType(v5, "string", "universeId");
    v2.isType(v6, "string", "source");
    v2.isType(v7, "number", "index");
    if l_Players_0.LocalPlayer then
        v3:setRBXEventStream("GameDetailsPeekView", v4, {
            uid = tostring(l_Players_0.LocalPlayer.UserId),
            locale = l_LocalizationService_0.RobloxLocaleId,
            universeId = v5,
            source = v6,
            index = v7
        });
    end;
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v2 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
local v3 = require(l_Modules_0.LuaApp.Models.AutocompleteSuggestion);
local v5 = {
    getSuggestionNameTypeStrings = function(v4)
        v2.isType(v4.type, "number", "entry.type");
        if v4.type == v3.EntryType.Keyword then
            v2.isType(v4.searchQuery, "string", "entry.searchQuery");
            return {
                name = v4.searchQuery,
                type = "kwd"
            };
        elseif v4.type == v3.EntryType.Rich then
            v2.isType(v4.canonicalTitle, "string", "entry.canonicalTitle");
            return {
                name = v4.canonicalTitle,
                type = "rich"
            };
        else
            return {
                name = "unknown",
                type = "unknown"
            };
        end;
    end
};
v5.convertSuggestionsToString = function(v6)
    v2.isType(v6, "table", "suggestions");
    if v6 then
        local v7 = {};
        for v8 = 1, #v6 do
            local v9 = v5.getSuggestionNameTypeStrings(v6[v8]);
            table.insert(v7, v9.name .. "|" .. v9.type);
        end;
        return table.concat(v7, ",");
    else
        return "";
    end;
end;
return v5;


local v0 = require(game:GetService("CoreGui").RobloxGui.Modules.LuaApp.Services.RoactAnalytics);
return {
    get = function(v1)
        local v2 = v0.get(v1);
        return {
            joinWithoutVoiceChat = function(v3)
                v2.EventStream:sendEventDeferred("voiceChat", "joinWithoutVoiceChat", {
                    dontShowAgain = v3
                });
            end,
            closeEnableVoiceChatModal = function()
                v2.EventStream:sendEventDeferred("voiceChat", "closeEnableVoiceChatModal");
            end,
            enableVoiceChatUpsell = function()
                v2.EventStream:sendEventDeferred("voiceChat", "enableVoiceChatUpsell");
            end,
            showEnableVoiceChatModal = function()
                v2.EventStream:sendEventDeferred("voiceChat", "showEnableVoiceChatModal");
            end,
            learnMoreAboutVoiceRecordingUpsell = function()
                v2.EventStream:sendEventDeferred("voiceChat", "learnMoreAboutVoiceRecordingUpsell");
            end
        };
    end
};


return function(v0, v1, v2, v3)
    assert(type(v2) == "string", "expected promptType to be a string");
    assert(type(v3) == "string", "expected modalState to be a string");
    v0:setRBXEventStream(v1, "accountSecurityPromptEvent", {
        promptType = v2,
        state = v3
    });
end;


return function(v0, v1, v2)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected appStage to be a string");
    v0:setRBXEventStream(v1, "appStageLoaded", {
        stage = v2
    });
end;


return function(v0, v1, v2, v3)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected buttonName to be a string");
    local v4 = {
        btn = v2
    };
    if v3 ~= nil then
        assert(type(v3) == "string", "Expected extraData to be a string");
        v4.cstm = v3;
    end;
    v0:setRBXEventStream(v1, "buttonClick", v4);
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local v1 = require(game:GetService("CorePackages").Workspace.Packages.ArgCheck);
local v2 = require(game:GetService("CoreGui").RobloxGui.Modules.LuaApp.Analytics.Events.SearchEventUtil);
return function(v3, v4, v5, v6, v7, v8)
    v1.isType(v4, "string", "eventContext");
    v1.isType(v5, "string", "kwd");
    v1.isType(v7, "string", "page");
    local v9 = 0;
    if v6 == true then
        v9 = 1;
    end;
    local v10 = "";
    if v8 then
        v10 = v2.convertSuggestionsToString(v8);
    end;
    v3:sendEventDeferred(v4, "catalogSearch", {
        locale = l_LocalizationService_0.RobloxLocaleId,
        kwd = v5,
        autoCompleteFlag = v9,
        previousPage = v7,
        suggestions = v10
    });
end;


return function(v0, v1, v2, v3, v4)
    assert(type(v1) == "string", "Expected context to be a string");
    assert(type(v2) == "string", "Expected name to be a string");
    assert(type(v3) == "string", "Expected oldValue to be a string");
    assert(type(v4) == "string", "Expected newValue to be a string");
    v0:setRBXEventStream(v1, "changeAccessibilitySetting", {
        name = v2,
        oldValue = v3,
        newValue = v4
    });
end;


return function(v0, v1, v2, v3)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected field to be a string");
    assert(type(v3) == "string", "Expected errorText to be a string");
    v0:setRBXEventStream(v1, "formFieldValidation", {
        field = v2,
        error = v3
    });
end;


return function(v0, v1, v2, v3, v4, v5)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected field to be a string");
    assert(type(v3) == "string", "Expected actionType to be a string");
    if v4 ~= nil then
        assert(type(v4) == "string", "Expected origin to be a string");
    end;
    if v5 ~= nil then
        assert(type(v5) == "string", "Expected btn to be a string");
    end;
    v0:setRBXEventStream(v1, "formInteraction", {
        field = v2,
        aType = v3,
        origin = v4,
        btn = v5
    });
end;


local l_Players_0 = game:GetService("Players");
return function(v1, v2, v3, v4, v5, v6, v7)
    assert(type(v2) == "string", "Expected playerId to be a string");
    assert(type(v3) == "string", "Expected placeId to be a string");
    assert(type(v4) == "number", "Expected rootPlaceId to be a number");
    if v5 then
        assert(type(v5) == "string", "Expected gameInstanceId to be a string");
    end;
    if v6 then
        assert(type(v6) == "string", "Expected joinAttemptId to be a string");
    end;
    if v7 then
        assert(type(v7) == "string", "Expected source to be a string");
    end;
    v1:setRBXEventStream("PlacesList", "joinGameInPlacesList", {
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        playerId = v2,
        placeId = v3,
        rootPlaceId = v4,
        gameInstanceId = v5,
        joinAttemptJoinId = v6,
        source = v7
    });
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local l_CorePackages_0 = game:GetService("CorePackages");
local v2 = require(l_CorePackages_0.Packages.Cryo);
local v3 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
local v4 = require(script.Parent.Parent.Parent.Flags.GetFFlagAddPreviousPageToLuaPageLoad);
return function(v5, v6, v7, v8, v9)
    v3.isType(v6, "string", "eventContext");
    v3.isType(v7, "string", "name");
    if v8 ~= nil then
        if type(v8) == "number" then
            v8 = tostring(v8);
        end;
        if type(v8) ~= "string" then
            v8 = nil;
        end;
    end;
    local v10 = {
        page = v7,
        detail = v8,
        locale = l_LocalizationService_0.RobloxLocaleId
    };
    if v4() and v9 ~= nil then
        v10 = v2.Dictionary.join(v10, v9);
    end;
    v5:setRBXEventStream(v6, "luaPageLoad", v10);
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v3 = require(l_Modules_0.LuaApp.ArgCheck);
local v4 = require(l_CorePackages_0.Cryo);
local v5 = require(l_Modules_0.LuaApp.Flags.GetFStringLuaAppUnloadEventEnabledPageNames);
local _ = function(v6)
    local v7 = v5();
    if v7 and #v7 > 0 then
        for _, v9 in string.split(v7, ",") do
            if v9 == v6 then
                return true;
            end;
        end;
    end;
    return false;
end;
return function(v11, v12, v13, v14, v15)
    v3.isType(v12, "string", "eventContext");
    v3.isType(v13, "string", "name");
    local v16 = v5();
    local v17;
    if v16 and #v16 > 0 then
        for _, v19 in string.split(v16, ",") do
            if v19 == v13 then
                v17 = true;
                goto label0 --[[  true, false  ]];
            end;
        end;
    end;
    v17 = false;
    ::label0::;
    if v17 then
        if v14 ~= nil then
            if type(v14) == "number" then
                v14 = tostring(v14);
            end;
            if type(v14) ~= "string" then
                v14 = nil;
            end;
        end;
        v16 = {
            page = v13,
            detail = v14,
            locale = l_LocalizationService_0.RobloxLocaleId
        };
        if v15 then
            v16 = v4.Dictionary.join(v16, v15);
        end;
        v11:setRBXEventStream(v12, "luaPageUnload", v16);
    end;
end;


return function(v0, v1, v2, v3)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected actionType to be a string");
    v0:setRBXEventStream(v1, "modalAction", {
        aType = v2,
        origin = v3
    });
end;


return function(v0, v1, v2)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "number", "Expected countOfUnreadNotifications to be a number");
    v0:setRBXEventStream(v1, "nsOpenCTAShown", {
        count = v2
    });
end;


return function(v0, v1, v2)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "number", "Expected countOfUnreadNotifications to be a number");
    v0:setRBXEventStream(v1, "nsOpenContent", {
        property = v2
    });
end;


return function(v0, v1)
    assert(type(v1) == "string", "Expected placeId to be a string");
    v0:setRBXEventStream("PlacesList", "openModalFromGameTile", {
        placeId = v1
    });
end;


return function(v0, v1, v2, v3, v4, v5)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    v0:setRBXEventStream(v1, "openYouTubeVideo", {
        videoTitle = v2,
        videoID = v3,
        universeId = v4,
        interactionType = v5
    });
end;


return function(v0, v1, v2)
    assert(type(v1) == "number", "Expected beatInterval to be a number");
    v0:setRBXEventStream(string.format("%s%d", "heartbeat", v1), "pageHeartbeat", {
        url = v2
    });
end;


local l_Players_0 = game:GetService("Players");
return function(v1, v2, v3, v4, v5, v6, v7)
    assert(type(v2) == "string", "Expected buttonName to be a string");
    assert(type(v3) == "string", "Expected friendId to be a string");
    assert(type(v4) == "number", "Expected position to be a number");
    local v8 = true;
    if v5 ~= nil then
        v8 = type(v5) == "string";
    end;
    assert(v8, "Expected context to be nil or string");
    assert(type(v6) == "number", "Expected absolutePosition to be a number");
    v8 = true;
    if v7 ~= nil then
        v8 = type(v7) == "table";
    end;
    assert(v8, "Expected extraArgs to be nil or table");
    v1:setRBXEventStream(v5 or "contactFriendFinder", "buttonClick", {
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        friendId = v3,
        position = v4,
        btn = v2,
        absolutePosition = v6,
        universeId = if not v7 then nil else v7.universeId,
        source = if not v7 then nil else v7.source
    });
end;


local l_Players_0 = game:GetService("Players");
return function(v1, v2, v3, v4, v5, v6)
    assert(type(v2) == "string", "Expected friendId to be a string");
    assert(type(v3) == "number", "Expected position to be a number");
    assert(type(v5) == "number", "Expected number to be a string");
    assert(type(v6) == "string", "Expected fromWhere to be a string");
    assert(type(v4) == "number", "Expected absolutePosition to be a number");
    v1:setRBXEventStream("contactFriendFinder", "goToGameDetailInPeopleList", {
        uid = tostring(l_Players_0.LocalPlayer.UserId),
        friendId = v2,
        position = v3,
        absolutePosition = v4,
        rootPlaceId = v5,
        fromWhere = v6
    });
end;


local l_RbxAnalyticsService_0 = game:GetService("RbxAnalyticsService");
local l_Platform_0 = game:GetService("UserInputService"):GetPlatform();
local l_FStringLuaAppEphemeralCounterPrefix_0 = require(game:GetService("CorePackages").Workspace.Packages.SharedFlags).FStringLuaAppEphemeralCounterPrefix;
return function(v3, v4)
    pcall(function()
        assert(type(v3) == "string", "Expected counterName to be a string");
        v3 = v3 or "";
        v4 = v4 or 1;
        if l_Platform_0 == Enum.Platform.Android then
            v3 = "Android-" .. tostring(v3);
        elseif l_Platform_0 == Enum.Platform.IOS then
            v3 = "iOS-" .. tostring(v3);
        elseif l_Platform_0 == Enum.Platform.Windows then
            v3 = "Win32-" .. tostring(v3);
        elseif l_Platform_0 == Enum.Platform.UWP then
            v3 = "UWP-" .. tostring(v3);
        elseif l_Platform_0 == Enum.Platform.OSX then
            v3 = "Mac-" .. tostring(v3);
        elseif l_FStringLuaAppEphemeralCounterPrefix_0 ~= "" then
            v3 = l_FStringLuaAppEphemeralCounterPrefix_0 .. tostring(v3);
        end;
        l_RbxAnalyticsService_0:ReportCounter(v3, v4);
    end);
end;


return function(v0, v1)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    v0:setRBXEventStream(v1, "screenLoaded", nil);
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
return function(v1, v2, v3, v4, v5)
    assert(type(v2) == "string", "Expected eventContext to be a string");
    assert(type(v3) == "string", "Expected act to be a string");
    if v4 then
        assert(type(v4) == "string", "Expected keyword to be a string");
    end;
    v1:setRBXEventStream(v2, "search", {
        act = v3,
        kwd = v4,
        locale = l_LocalizationService_0.RobloxLocaleId,
        isAutoSearchType = v5
    });
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v3 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
local v4 = require(l_Modules_0.LuaApp.Analytics.Events.SearchEventUtil);
local v5 = require(l_Modules_0.LuaApp.Flags.GetFIntLuaAppAutocompleteDebounceMs);
return function(v6, v7, v8, v9, v10, v11, v12, v13)
    if v8 == v9 then
        return ;
    else
        v3.isType(v7, "string", "eventContext");
        v3.isType(v8, "string", "kwd");
        v3.isType(v9, "string", "prevKwd");
        v3.isType(v10, "table", "suggestion");
        v3.isType(v11, "string", "page");
        v6:setRBXEventStream(v7, "searchAutocomplete", {
            locale = l_LocalizationService_0.RobloxLocaleId,
            suggestions = v4.convertSuggestionsToString(v10.entries),
            kwd = v8,
            prevKwd = v9,
            page = v11,
            latency = v12,
            fromLocalCache = v13,
            algorithm = v10.algorithmName,
            timeoutDelayMs = v5()
        });
        return ;
    end;
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v3 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
local v4 = require(l_Modules_0.LuaApp.Analytics.Events.SearchEventUtil);
local v5 = require(l_Modules_0.LuaApp.Flags.GetFIntLuaAppAutocompleteDebounceMs);
return function(v6, v7, v8, v9, v10, v11, v12, v13, v14)
    if v8 == v9 then
        return ;
    else
        v3.isType(v7, "string", "eventContext");
        v3.isType(v8, "string", "kwd");
        v3.isType(v9, "string", "prevKwd");
        v3.isType(v10, "table", "suggestion");
        v3.isType(v11, "string", "page");
        v6:sendEventDeferred(v7, "searchAutocomplete", {
            locale = l_LocalizationService_0.RobloxLocaleId,
            suggestions = v4.convertSuggestionsToString(v10.entries),
            kwd = v8,
            prevKwd = v9,
            page = v11,
            latency = v12,
            fromLocalCache = v13,
            algorithm = v10.algorithmName,
            timeoutDelayMs = v5(),
            maxResults = #v10.entries,
            searchType = v14,
            searchBox = "mobile"
        });
        return ;
    end;
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local v1 = require(game:GetService("CorePackages").Workspace.Packages.ArgCheck);
return function(v2, v3, v4, v5)
    v1.isType(v3, "string", "eventContext");
    v1.isType(v4, "string", "kwd");
    v1.isType(v5, "string", "searchType");
    v2:setRBXEventStream(v3, "searchClear", {
        locale = l_LocalizationService_0.RobloxLocaleId,
        kwd = v4,
        searchType = v5
    });
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v3 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
local v4 = require(l_Modules_0.LuaApp.Analytics.Events.SearchEventUtil);
return function(v5, v6, v7, v8, v9, v10, v11)
    v3.isType(v6, "string", "eventContext");
    v3.isType(v7, "string", "kwd");
    v3.isType(v8, "string", "searchType");
    v3.isType(v9, "table", "entries");
    v3.isType(v10, "number", "clickedPos");
    v3.isType(v11, "table", "clickedEntry");
    local l_RobloxLocaleId_0 = l_LocalizationService_0.RobloxLocaleId;
    local v13 = v4.getSuggestionNameTypeStrings(v11);
    v5:setRBXEventStream(v6, "searchSuggestionClicked", {
        locale = l_RobloxLocaleId_0,
        kwd = v7,
        searchType = v8,
        suggestions = v4.convertSuggestionsToString(v9),
        suggestionPosition = v10,
        suggestionClicked = v13.name,
        suggestionType = v13.type,
        maxResults = #v9
    });
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local v1 = require(game:GetService("CorePackages").Workspace.Packages.ArgCheck);
return function(v2, v3, v4, v5, v6)
    v1.isType(v3, "string", "eventContext");
    v1.isType(v4, "string", "kwd");
    v1.isType(v5, "string", "resultingKwd");
    v1.isType(v6, "string", "searchType");
    v2:setRBXEventStream(v3, "searchTextTrim", {
        locale = l_LocalizationService_0.RobloxLocaleId,
        kwd = v4,
        resultingKwd = v5,
        searchType = v6
    });
end;


local v0 = require(game:GetService("CorePackages").Workspace.Packages.ArgCheck);
local v1 = {
    [Enum.SwipeDirection.Up] = "up",
    [Enum.SwipeDirection.Right] = "right",
    [Enum.SwipeDirection.Down] = "down",
    [Enum.SwipeDirection.Left] = "left"
};
return function(v2, v3, v4, v5, v6)
    v0.isType(v3, "string", "eventContext");
    v0.isType(v4, "string", "elementName");
    local v7 = {
        elt = v4,
        dir = v1[v5]
    };
    if v6 ~= nil then
        v0.isType(v6, "string", "extraData");
        v7.cstm = v6;
    end;
    v2:setRBXEventStream(v3, "touchSwipe", v7);
end;


return function(v0, v1)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    v0:setRBXEventStream(v1, "userInteractions", nil);
end;


return function(v0, v1, v2, v3, v4)
    assert(type(v1) == "string", "Expected eventContext to be a string");
    assert(type(v2) == "string", "Expected buttonName to be a string");
    assert(type(v3) == "string", "Expected userField to be a string");
    assert(type(v4) == "string", "Expected suggestion to be a string");
    v0:setRBXEventStream(v1, "buttonClick", {
        btn = v2,
        userField = v3,
        suggestion = v4
    });
end;


local l_UserModel_0 = require(game:GetService("CorePackages").Workspace.Packages.UserLib).Models.UserModel;
return function(v1, v2)
    local l_FriendCount_0 = v1.FriendCount;
    local v4 = v1.FriendPresenceCounts[l_UserModel_0.PresenceType.ONLINE] or 0;
    local v5 = v1.FriendPresenceCounts[l_UserModel_0.PresenceType.IN_GAME] or 0;
    v2.EventStream:setRBXEventStream("onlineFriends", "usersFriendsPresenceOnAppStartup", {
        onlineFriendCount = v4 + v5,
        inGameFriendCount = v5,
        totalFriendCount = l_FriendCount_0
    });
end;


local v0 = require(game:GetService("CorePackages").Workspace.Packages.LoggingProtocol);
game:DefineFastInt("LuaAppChallengeNativeWrapperEventThrottleHundredthsPercent", 10000);
return {
    eventName = "accountSecurityChallengeNativeWrapperEvent",
    backends = {
        v0.TelemetryBackends.EventIngest
    },
    throttlingPercentage = game:GetFastInt("LuaAppChallengeNativeWrapperEventThrottleHundredthsPercent"),
    lastUpdated = {
        24,
        4,
        17
    },
    description = "Tracks lifecycle events for Lua GCS challenges",
    links = "https://roblox.atlassian.net/wiki/spaces/BaS/pages/2184872709/Bypassing+Challenges+for+Xbox+PS+Quest+etc+Requests#Event-Tracking"
};


local v0 = require(game:GetService("CorePackages").Workspace.Packages.LoggingProtocol);
game:DefineFastInt("LuaAppChallengeDeviceAccessEventThrottlingPercent", 10000);
return {
    eventName = "accountSecurityChallengeDeviceAccessTokenEvent",
    backends = {
        v0.TelemetryBackends.EventIngest
    },
    throttlingPercentage = game:GetFastInt("LuaAppChallengeDeviceAccessEventThrottlingPercent"),
    lastUpdated = {
        24,
        1,
        22
    },
    description = "Tracks lifecycle events for the Device Access GCS challenge",
    links = "https://roblox.atlassian.net/wiki/spaces/BaS/pages/2184872709/Bypassing+Challenges+for+Xbox+PS+Quest+etc+Requests#Event-Tracking"
};


return {
    eventName = "accountSecurityChallengeDeviceIntegrityEvent",
    backends = {
        require(game:GetService("CorePackages").Workspace.Packages.LoggingProtocol).TelemetryBackends.EventIngest
    },
    throttlingPercentage = 10000,
    lastUpdated = {
        24,
        1,
        22
    },
    description = "Tracks lifecycle events for the Device Integrity GCS challenge",
    links = "https://roblox.atlassian.net/wiki/spaces/BaS/pages/2184872709/Bypassing+Challenges+for+Xbox+PS+Quest+etc+Requests#Event-Tracking"
};


local v0 = require(game:GetService("CorePackages").Workspace.Packages.LoggingProtocol);
game:DefineFastInt("LoginByUsernameSSOErrorsThrottleHundrethsPercent", 0);
return {
    eventName = "LoginByUsernameSSOErrors",
    backends = {
        v0.TelemetryBackends.Points
    },
    throttlingPercentage = game:GetFastInt("LoginByUsernameSSOErrorsThrottleHundrethsPercent"),
    lastUpdated = {
        24,
        5,
        3
    },
    description = "Report LoginByUsernameSSO Error codes to Points with document name \"loginbyusernamessoerrors\""
};


local v0 = require(game:GetService("CorePackages").Workspace.Packages.LoggingProtocol);
game:DefineFastInt("LuaLogoutReasonsThrottleHundrethsPercent", 0);
return {
    eventName = "LuaLogoutReasons",
    backends = {
        v0.TelemetryBackends.Points
    },
    throttlingPercentage = game:GetFastInt("LuaLogoutReasonsThrottleHundrethsPercent"),
    lastUpdated = {
        23,
        2,
        16
    },
    description = "Report Lua logout reasons to Points with document name \"lualogoutreasons\"",
    links = "https://roblox.atlassian.net/wiki/spaces/AUTH/pages/1972602346/Logout+telemetry+for+Universal+App"
};


local v0 = require(game:GetService("CorePackages").Workspace.Packages.LoggingProtocol);
game:DefineFastInt("ToCPopupOccuranceThrottleHundrethsPercent", 0);
return {
    eventName = "ToCPopupOccurance",
    backends = {
        v0.TelemetryBackends.Points
    },
    throttlingPercentage = game:GetFastInt("ToCPopupOccuranceThrottleHundrethsPercent"),
    lastUpdated = {
        23,
        3,
        8
    },
    description = "Report ocurrance of ToC popup"
};


local l_HttpService_0 = game:GetService("HttpService");
local l_SessionType_0 = require(game:GetService("CorePackages").Workspace.Packages.RobloxAppSessionization).SessionType;
return {
    generateUuid = function()
        return l_HttpService_0:GenerateGUID(true);
    end,
    create = function(v2, v3, v4, v5)
        local v6 = true;
        if v2:SessionExists(l_SessionType_0.StructuralIdentifier.OmniSearch) and v2:GetMetadata(l_SessionType_0.StructuralIdentifier.OmniSearch, l_SessionType_0.Metadata.OmniSearch.OmniSearchUuid) == v3 then
            v6 = false;
        end;
        if v6 then
            v2:SetSession(l_SessionType_0.StructuralIdentifier.Level1, l_SessionType_0.StructuralIdentifier.OmniSearch, l_SessionType_0.StructuralIdentifier.OmniSearch);
            v2:SetMetadata(l_SessionType_0.StructuralIdentifier.OmniSearch, l_SessionType_0.Metadata.OmniSearch.OmniSearchUuid, v3);
        end;
        v2:SetMetadata(l_SessionType_0.StructuralIdentifier.OmniSearch, l_SessionType_0.Metadata.OmniSearch.SearchKeyword, v4);
        v2:SetMetadata(l_SessionType_0.StructuralIdentifier.OmniSearch, l_SessionType_0.Metadata.OmniSearch.SearchType, v5);
    end,
    updateSearchType = function(v7, v8)
        if v7:SessionExists(l_SessionType_0.StructuralIdentifier.OmniSearch) then
            v7:SetMetadata(l_SessionType_0.StructuralIdentifier.OmniSearch, l_SessionType_0.Metadata.OmniSearch.SearchType, v8);
        end;
    end
};


local l_SessionType_0 = require(game:GetService("CorePackages").Workspace.Packages.RobloxAppSessionization).SessionType;
return function(v1, v2, v3)
    v1:SetSession(l_SessionType_0.StructuralIdentifier.Level1, l_SessionType_0.StructuralIdentifier.GameSearch, l_SessionType_0.StructuralIdentifier.GameSearch);
    v1:SetMetadata(l_SessionType_0.StructuralIdentifier.GameSearch, l_SessionType_0.Metadata.GameSearch.SearchUuid, v2);
    v1:SetMetadata(l_SessionType_0.StructuralIdentifier.GameSearch, l_SessionType_0.Metadata.GameSearch.SearchKeyword, v3);
end;


local v0 = require(game:GetService("CoreGui").RobloxGui.Modules.LuaApp.AppPageProperties);
local v1 = {};
for v2, v3 in pairs(v0) do
    v1[v2] = v3.nameLocalizationKey;
end;
return v1;


game:DefineFastFlag("LuaAppBootcampExample", false);
return function()
    return game:GetFastFlag("LuaAppBootcampExample");
end;


local l_Flags_0 = script.Parent.Flags;
local v1 = require(l_Flags_0.GetFFlagLuaAppBootcampExample);
local _ = require(l_Flags_0.FFlagLuaAppBootcampIntroMOBLUAPP3345);
local v3 = require(l_Flags_0.FFlagLuaAppBootcampIntroUABOOTCAMP1);
local v4 = require(l_Flags_0.FFlagLuaAppBootcampIntroUABOOTCAMP4);
local v5 = {};
if v1() then
    table.insert(v5, "Bootcamp example flag is on");
end;
if v3 then
    table.insert(v5, "Hello world, this is IndeliblePlatypus");
end;
if v4 then
    table.insert(v5, "Hello world, this is QuirkySquid");
end;
return v5;


game:DefineFastFlag("EnableLuaAppBootcamp", false);
return function()
    return game:GetFastFlag("EnableLuaAppBootcamp");
end;


local v0 = require(game:GetService("CorePackages").Logging);
v0.warn("Lua App Bootcamp Enabled");
local v1 = {};
local v2 = require(script.Parent.Parent.LuaAppIntroBootcamp);
v1.runBootcamp = function(_)
    for _, v5 in ipairs(v2) do
        v0.warn(v5);
    end;
end;
return v1;


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v1 = require(l_Modules_0.LuaApp.AppPage);
return {
    {
        page = v1.Home,
        icon = {
            on = "LuaApp/icons/menu/home_on",
            off = "LuaApp/icons/menu/home_off"
        },
        actionType = Enum.AppShellActionType.TapHomePageTab,
        badgeCount = 0
    },
    {
        page = v1.Games,
        icon = {
            on = "LuaApp/icons/menu/games_on",
            off = "LuaApp/icons/menu/games_off"
        },
        actionType = Enum.AppShellActionType.TapGamePageTab,
        badgeCount = 0
    },
    {
        page = v1.AvatarExperienceRoot,
        iconComponent = require(l_Modules_0.AvatarExperience.Common.Components.AvatarHeadshotSystemBarIcon),
        actionType = Enum.AppShellActionType.TapAvatarTab,
        badgeCount = 0
    },
    {
        page = v1.Chat,
        icon = {
            on = "LuaApp/icons/menu/chat_on",
            off = "LuaApp/icons/menu/chat_off"
        },
        actionType = Enum.AppShellActionType.TapChatTab,
        badgeCount = 0
    },
    {
        page = v1.More,
        icon = {
            on = "LuaApp/icons/menu/more_on",
            off = "LuaApp/icons/menu/more_off"
        },
        actionType = nil,
        badgeCount = 0
    }
};


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Cryo);
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.Dash);
local v5 = require(l_CorePackages_0.Packages.t);
local l_RoactNetworking_0 = require(l_CorePackages_0.Workspace.Packages.RoactServiceTags).RoactNetworking;
local v7 = require(l_CorePackages_0.Workspace.Packages.GamePlayButton);
local l_usePlayButtonState_0 = v7.usePlayButtonState;
local l_useOnPlayButtonCallback_0 = v7.useOnPlayButtonCallback;
local l_useRoactService_0 = require(l_CorePackages_0.Workspace.Packages.RobloxAppHooks).useRoactService;
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v12 = require(l_Modules_0.LuaApp.Common.wrapComponent);
local v13 = require(l_Modules_0.AvatarExperience.Flags.FFlagEnableAttributionItemRow);
return {
    connect = function(v14, v15)
        return function(v16)
            local v17 = v2.PureComponent:extend("LaunchExperienceConnector(" .. tostring(v16) .. ")");
            v17.validateProps = v5.interface({
                componentProps = v5.table,
                universeId = v5.string,
                launchSource = v5.optional(v5.string),
                eventContext = v5.optional(v5.string),
                referralSource = v5.optional(v5.string),
                fetchDelayInSeconds = v5.optional(v5.number)
            });
            v17.init = function(v18)
                v18.onPlayButtonActivated = function(v19, v20)
                    v18.props.onPlayButtonCallback(v19 or v18.props.playButtonState, v20);
                end;
            end;
            v17.render = function(v21)
                return v2.createElement(v16, v4.assign({}, v21.props.componentProps, v15({
                    playabilityStatus = v21.props.playabilityStatus,
                    playButtonState = v21.props.playButtonState,
                    onPlayButtonActivated = v21.onPlayButtonActivated,
                    gameName = if not v13 then nil else v21.props.gameName,
                    fetchDelayInSeconds = v21.props.fetchDelayInSeconds
                }, v21.props.componentProps)));
            end;
            local l_v17_0 = v17;
            return v12(function(v23, v24)
                local v25 = v14(v24);
                return v2.createElement(v23, {
                    componentProps = v24,
                    universeId = v25.universeId,
                    launchSource = v25.launchSource,
                    eventContext = v25.eventContext,
                    referralSource = v25.referralSource,
                    fetchDelayInSeconds = v25.fetchDelayInSeconds
                });
            end)((v3.connect(function(v26, v27)
                local v28 = v26.GameDetails[v27.universeId];
                local v29 = v26.Games[v27.universeId];
                return {
                    gameName = (not not v28 and v28.name or v29 and v29.name) or nil
                };
            end)(function(v30)
                local v31 = l_usePlayButtonState_0(l_useRoactService_0(l_RoactNetworking_0), v30.universeId, v30.fetchDelayInSeconds);
                return v2.createElement(l_v17_0, (v1.Dictionary.join(v30, {
                    onPlayButtonCallback = l_useOnPlayButtonCallback_0(v30.universeId, v30.referralSource, v30.eventContext or "PlayButton", nil, v30.launchSource or "UnknownLaunchSource"),
                    playButtonState = v31.playButtonState,
                    playabilityStatus = v31.playabilityStatus
                })));
            end)));
        end;
    end
};


local v0 = require(game:GetService("CoreGui").RobloxGui.Modules.LuaApp.Enum.PlayButtonStates);
return function(v1, v2)
    assert(v1 ~= nil, "Expect playButtonState ~= nil");
    local v3 = {};
    if v1 == v0.Loading then
        v3.icon = "icons/status/unavailable";
        v3.isLoading = true;
        v3.isDisabled = true;
        return v3;
    elseif v1 == v0.Playable then
        v3.icon = "icons/common/play";
        v3.isDisabled = false;
        return v3;
    elseif v1 == v0.PaidAccess then
        assert(v2 ~= nil, "gameProductInfo cannot be nil when PlayButtonStates.PaidAccess");
        v3.price = v2.price;
        v3.icon = "icons/common/robux";
        v3.isDisabled = false;
        return v3;
    elseif v1 == v0.Private then
        v3.icon = "icons/status/private";
        v3.textKey = "Feature.ExperienceDetails.PlayButtonText.Private";
        v3.isDisabled = true;
        return v3;
    elseif v1 == v0.UnplayableOther then
        v3.icon = "icons/status/unavailable";
        v3.isDisabled = true;
        return v3;
    else
        v3.icon = "icons/status/unavailable";
        v3.isDisabled = true;
        return v3;
    end;
end;


local function v0(v1, v2, ...)
    if v2 then
        if type(v1) ~= "table" then
            return nil;
        else
            return v0(v1[v2], ...);
        end;
    else
        return v1;
    end;
end;
return v0;


local l_RunService_0 = game:GetService("RunService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v3 = require(l_CorePackages_0.Packages.React);
local l_AppRunService_0 = require(l_CorePackages_0.Workspace.Packages.RoactServiceTags).AppRunService;
local l_RoactAppPolicy_0 = require(l_CorePackages_0.Workspace.Packages.UniversalAppPolicy).RoactAppPolicy;
local v6 = require(l_Modules_0.LuaApp.Hooks.useRoactService);
local l_Object_0 = require(l_CorePackages_0.Packages.LuauPolyfill).Object;
return function(v8)
    return v3.forwardRef(function(v9, v10)
        local v11 = v6(l_AppRunService_0) or l_RunService_0;
        return v3.createElement(v3.useMemo(function()
            return l_RoactAppPolicy_0.connect(function(v12)
                return {
                    setThrottleFramerateEnabled = function(v13)
                        if v12.getThrottleFramerate() then
                            v11:setThrottleFramerateEnabled(v13);
                        end;
                    end
                };
            end)(v8);
        end, {
            v8,
            v11
        }), l_Object_0.assign(v9, {
            ref = v10
        }));
    end);
end;


local _ = require(game:GetService("CorePackages").Packages.React);
return function(v1)
    return function(v2)
        return function(v3)
            return v1(v2, v3);
        end;
    end;
end;


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local l_CorePackages_0 = game:GetService("CorePackages");
local l_LocalizationService_0 = game:GetService("LocalizationService");
local v3 = require(l_CorePackages_0.Packages.React);
local v4 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportComingSoonPrompt);
local v5 = require(l_CorePackages_0.Workspace.Packages.SharedFlags);
local v6 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportDialogController);
local v7 = require(l_Modules_0.LuaApp.Components.AbuseReporting.Constants);
local _ = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportTypes);
local v9 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportAnalytics);
local _ = v9.ActionTypes;
local l_GetFFlagLuafiedReportFullFlow_0 = v5.GetFFlagLuafiedReportFullFlow;
local l_GetFFlagVRAbuseReportLocales_0 = v5.GetFFlagVRAbuseReportLocales;
local l_useNavigation_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).Hooks.useNavigation;
local v14 = require(l_Modules_0.AvatarExperience.Common.Components.withOverlayFocusHandling);
local v15 = require(l_Modules_0.AvatarExperience.Common.Components.RoactNavigation.NavigationUtils);
return (v14(function()
    local v16 = l_useNavigation_0();
    local v17, v18 = v3.useReducer(v9.reportAnalyticsReducer, v9.EMPTY_LOGGING_STATE);
    local function v19()
        v15.closeOverlay(v16);
    end;
    local v20 = v3.useCallback(function()
        v9.sendEventData(v17, v7.ANALYTICS_EVENT_NAMES.ABANDONED);
    end, {
        v18,
        v17
    });
    local v21 = v3.useCallback(function()
        v18({
            type = v9.ActionTypes.SET_IS_SEEN_SUMMARY_PAGE
        });
    end, {
        v18,
        v17
    });
    local v22 = {
        reportEntryPoint = v7.REPORT_ENTRYPOINT.Item,
        assetTypeName = v16.getParam("assetTypeName"),
        itemId = v16.getParam("itemId"),
        itemName = v16.getParam("itemName"),
        itemCreatorName = v16.getParam("itemCreatorName")
    };
    if not l_GetFFlagLuafiedReportFullFlow_0() then
        return (v3.createElement(v4, {
            onClose = v19
        }));
    else
        return (v3.createElement(v6, {
            reportData = v22,
            reportSurface = v7.BEDUI_SURFACES.VR,
            locale = not l_GetFFlagVRAbuseReportLocales_0() and "en_us" or l_LocalizationService_0.RobloxLocaleId,
            submissionEntryPoint = v7.SAFETY_EVENT_SUBMISSION_ENTRY_POINT.VR,
            analyticsState = v17,
            analyticsDispatch = v18,
            onClose = v19,
            onSummaryPageMounted = v21,
            onLogAbandon = v20
        }));
    end;
end));


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(game:GetService("CoreGui").RobloxGui.Modules.LuaApp.Enum.ToastType);
local l_GetFFlagLuaAppNewStreamNotificationsEnabled_0 = require(l_CorePackages_0.Workspace.Packages.SharedFlags).GetFFlagLuaAppNewStreamNotificationsEnabled;
return {
    PROFILE_THUMBNAIL_DATA = {
        Size = 420,
        Type = "AvatarHeadShot"
    },
    EXP_THUMBNAIL_DATA = {
        Size = 512,
        Type = "GameIcon"
    },
    ITEM_THUMBNAIL_DATA = {
        Size = 420,
        Type = "Asset"
    },
    SUCCESS_TOAST_DATA = {
        toastMessage = "Feature.ReportAbuse.Label.Confirmation.Title",
        toastSubMessage = "Feature.ReportAbuse.Label.Confirmation.Subheading",
        isLocalized = false,
        toastType = v1.SuccessConfirmation
    },
    BEDUI_FETCH_FAILURE = "Feature.ReportAbuse.Message.ErrorBEDUIFetchFailed",
    REPORT_SUBMIT_LOADING = "Feature.ReportAbuse.Message.Loading",
    REPORT_SUBMIT_FAILURE = "Feature.ReportAbuse.Message.ErrorSubmitFailure",
    BEDUI_FETCH_FAILURE_PRIMARY = "Trouble Loading Report",
    BEDUI_FETCH_FAILURE_SECONDARY = "Something went wrong. Please try again.",
    BEDUI_BASE_URL = "abuse-reporting/v1/dynamic-dialog",
    BEDUI_SURFACES = {
        VR = "vr"
    },
    REPORT_ENTRYPOINT = {
        Profile = "Profile",
        Chat = "Chat",
        Item = "Item",
        ExperienceDetails = "ExperienceDetails",
        Notification = if not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() then nil else "Notification"
    },
    BEDUI_FETCH_CONTEXT = {
        Profile = "profile",
        Experience = "experience",
        Item = "item",
        Notification = if not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() then nil else "notification"
    },
    ABUSE_VECTOR = {
        UserProfile = "user_profile",
        Place = "place",
        Notification = if not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() then nil else "notifications"
    },
    SAFETY_EVENT_SUBMISSION_ENTRY_POINT = {
        VR = "vr",
        Phone = if not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() then nil else "phone",
        Tablet = if not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() then nil else "tablet",
        Desktop = if not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() then nil else "desktop"
    },
    ANALYTICS_EVENT_NAMES = {
        SUBMITTED = "TreeBasedAbuseReportSubmitted",
        ABANDONED = "TreeBasedAbuseReportAbandoned"
    },
    COMMON_FORMAT_ENTRY_POINT = {
        Profile = "profile",
        Experience = "experience",
        Item = "item",
        Chat = "chat"
    },
    BEDUI_VERSIONS = {
        V1 = "v1",
        DEV = "v_dev"
    }
};


local _ = game:GetService("RbxAnalyticsService");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local l_EventIngestService_0 = game:GetService("EventIngestService");
local v3 = require(l_Modules_0.LuaApp.Components.AbuseReporting.Constants);
local l_COMMON_FORMAT_ENTRY_POINT_0 = v3.COMMON_FORMAT_ENTRY_POINT;
local l_REPORT_ENTRYPOINT_0 = v3.REPORT_ENTRYPOINT;
local v6 = {
    platform = "",
    dialogEntryPoint = "",
    selectItemCount = 0,
    backButtonClickCount = 0,
    isSeenSummaryPage = false
};
local function v9(v7, v8)
    if v7.platform ~= "" and v7.dialogEntryPoint ~= "" then
        l_EventIngestService_0:SendEventDeferred(v7.platform, v7.dialogEntryPoint, v8, v7);
    end;
end;
local function v11(v10)
    if not ((v10 ~= l_COMMON_FORMAT_ENTRY_POINT_0.Profile and v10 ~= l_COMMON_FORMAT_ENTRY_POINT_0.Chat) and v10 ~= l_COMMON_FORMAT_ENTRY_POINT_0.Experience) or v10 == l_COMMON_FORMAT_ENTRY_POINT_0.Item then
        return v10;
    elseif v10 == l_REPORT_ENTRYPOINT_0.Profile then
        return l_COMMON_FORMAT_ENTRY_POINT_0.Profile;
    elseif v10 == l_REPORT_ENTRYPOINT_0.Chat then
        return l_COMMON_FORMAT_ENTRY_POINT_0.Chat;
    elseif v10 == l_REPORT_ENTRYPOINT_0.ExperienceDetails then
        return l_COMMON_FORMAT_ENTRY_POINT_0.Experience;
    elseif v10 == l_REPORT_ENTRYPOINT_0.Item then
        return l_COMMON_FORMAT_ENTRY_POINT_0.Item;
    else
        return "";
    end;
end;
local v12 = {
    SET_BASIC_INFO = "SET_BASIC_INFO",
    INCREMENT_SELECTION_ITEM = "INCREMENT_SELECTION_ITEM",
    INCREMENT_BACK_BUTTON_CLICK = "INCREMENT_BACK_BUTTON_CLICK",
    SET_IS_SEEN_SUMMARY_PAGE = "SET_IS_SEEN_SUMMARY_PAGE"
};
return {
    reportAnalyticsReducer = function(v13, v14)
        local v15 = table.clone(v13);
        if v14.type == v12.SET_BASIC_INFO then
            v15.platform = v14.platform;
            v15.dialogEntryPoint = v11(v14.dialogEntryPoint);
            return v15;
        elseif v14.type == v12.INCREMENT_SELECTION_ITEM then
            v15.selectItemCount = v15.selectItemCount + 1;
            return v15;
        elseif v14.type == v12.INCREMENT_BACK_BUTTON_CLICK then
            v15.backButtonClickCount = v15.backButtonClickCount + 1;
            return v15;
        else
            if v14.type == v12.SET_IS_SEEN_SUMMARY_PAGE then
                v15.isSeenSummaryPage = true;
            end;
            return v15;
        end;
    end,
    EMPTY_LOGGING_STATE = v6,
    sendEventData = v9,
    ActionTypes = v12
};


local _ = game:GetService("CoreGui").RobloxGui.Modules;
local l_CorePackages_0 = game:GetService("CorePackages");
local v2 = require(l_CorePackages_0.Packages.React);
local v3 = require(l_CorePackages_0.UIBlox);
local l_VRConstants_0 = require(l_CorePackages_0.Workspace.Packages.VrCompatibility).VRConstants;
local v5 = require(l_CorePackages_0.Workspace.Packages.Style);
local v6 = require(l_CorePackages_0.Workspace.Packages.ArgCheck);
local l_FullPageModal_0 = v3.App.Dialog.Modal.FullPageModal;
local l_useDesignTokens_0 = v5.useDesignTokens;
local l_mapTypographyVariantToFontEnum_0 = v5.mapTypographyVariantToFontEnum;
return function(v10)
    local v11 = l_useDesignTokens_0();
    v6.assert(false, "Report Dialog's title and body text have not been localized. This needs to be addressed before this feature is released.");
    return v2.createElement(l_FullPageModal_0, {
        title = "Reporting Coming Soon",
        onCloseClicked = v10.onClose,
        screenSize = l_VRConstants_0.MainScreenResolution
    }, {
        Texts = v2.createElement("Frame", {
            Size = UDim2.new(1, 0, 1, 0),
            BackgroundTransparency = 1
        }, {
            Layout = v2.createElement("UIListLayout", {
                HorizontalAlignment = Enum.HorizontalAlignment.Center,
                VerticalAlignment = Enum.VerticalAlignment.Center,
                SortOrder = Enum.SortOrder.LayoutOrder
            }),
            Padding = v2.createElement("UIPadding", {
                PaddingLeft = UDim.new(0, 15)
            }),
            PrimaryText = v2.createElement("TextLabel", {
                Text = "Reporting is coming soon to this platform.",
                Font = l_mapTypographyVariantToFontEnum_0(v11.Semantic.Typography.Subheader),
                LayoutOrder = 1,
                TextColor3 = v11.Semantic.Color.Text.Emphasis.Color3,
                TextTransparency = v11.Semantic.Color.Text.Emphasis.Transparency,
                TextSize = v11.Semantic.Typography.Subheader.FontSize,
                TextWrapped = true,
                TextXAlignment = Enum.TextXAlignment.Center,
                Size = UDim2.new(1, 0, 0, v11.Semantic.Typography.Subheader.FontSize),
                BackgroundTransparency = 1
            })
        })
    });
end;


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local l_CorePackages_0 = game:GetService("CorePackages");
local l_LocalizationService_0 = game:GetService("LocalizationService");
local v3 = require(l_CorePackages_0.Packages.React);
local v4 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportComingSoonPrompt);
local v5 = require(l_CorePackages_0.Workspace.Packages.SharedFlags);
local v6 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportDialogController);
local _ = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportTypes);
local v8 = require(l_Modules_0.LuaApp.Components.AbuseReporting.Constants);
local v9 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportAnalytics);
local l_useNavigation_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).Hooks.useNavigation;
local l_GetFFlagLuafiedReportFullFlow_0 = v5.GetFFlagLuafiedReportFullFlow;
local l_GetFFlagVRAbuseReportLocales_0 = v5.GetFFlagVRAbuseReportLocales;
local l_GetFFlagLuaAppNewStreamNotificationsEnabled_0 = v5.GetFFlagLuaAppNewStreamNotificationsEnabled;
local v14 = require(l_Modules_0.LuaApp.Thunks.NavigateBack);
local l_useDispatch_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).Hooks.RoactRodux.useDispatch;
return function()
    local v16 = l_useDispatch_0();
    local v17 = l_useNavigation_0();
    local v18, v19 = v3.useReducer(v9.reportAnalyticsReducer, v9.EMPTY_LOGGING_STATE);
    local v20 = v17.getParam("reportData");
    local function v21()
        if not ((not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() or not v20) or not v20.onCloseCallback) then
            v20.onCloseCallback();
        end;
        v16(v14());
    end;
    local v22 = v3.useCallback(function()
        v9.sendEventData(v18, v8.ANALYTICS_EVENT_NAMES.ABANDONED);
    end, {
        v19,
        v18
    });
    local v23 = v3.useCallback(function()
        v19({
            type = v9.ActionTypes.SET_IS_SEEN_SUMMARY_PAGE
        });
    end, {
        v19,
        v18
    });
    if l_GetFFlagLuafiedReportFullFlow_0() or not (not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() or not v20) and v20.reportEntryPoint == "Notification" then
        return (v3.createElement(v6, {
            reportSurface = if (not not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() and v20) and v20.reportSurface then v20.reportSurface else v8.BEDUI_SURFACES.VR,
            locale = not l_GetFFlagVRAbuseReportLocales_0() and "en_us" or l_LocalizationService_0.RobloxLocaleId,
            reportData = v20,
            submissionEntryPoint = if (not not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() and v20) and v20.submissionEntryPoint then v20.submissionEntryPoint else v8.SAFETY_EVENT_SUBMISSION_ENTRY_POINT.VR,
            analyticsState = v18,
            analyticsDispatch = v19,
            onClose = v21,
            onSummaryPageMounted = v23,
            onLogAbandon = v22
        }));
    else
        return (v3.createElement(v4, {
            onClose = v21
        }));
    end;
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local v2 = require(l_CorePackages_0.Packages.React);
local v3 = require(l_CorePackages_0.Workspace.Packages.Style);
local l_withLocalization_0 = require(l_CorePackages_0.Workspace.Packages.Localization).withLocalization;
local _ = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportTypes);
local _ = require(l_Modules_0.LuaApp.Components.AbuseReporting.Constants);
local l_useDesignTokens_0 = require(l_CorePackages_0.Workspace.Packages.Style).useDesignTokens;
local l_mapTypographyVariantToFontEnum_0 = v3.mapTypographyVariantToFontEnum;
return function(v9)
    local v10 = l_useDesignTokens_0();
    return l_withLocalization_0({
        statusPrimaryText = v9.statusPrimaryText,
        statusSecondaryText = v9.statusSecondaryText
    })(function(v11)
        return v2.createElement("Frame", {
            Size = UDim2.new(1, 0, 1, 0),
            AutomaticSize = Enum.AutomaticSize.XY,
            BackgroundTransparency = v10.Global.Opacity_0
        }, {
            FetchStatus = if not v9.submitError then if v9.BEDUIError then v2.createElement("Frame", {
                Size = UDim2.new(1, 0, 0.9, 0),
                AutomaticSize = Enum.AutomaticSize.XY,
                BackgroundTransparency = v10.Global.Opacity_0
            }, {
                Layout = v2.createElement("UIListLayout", {
                    HorizontalAlignment = Enum.HorizontalAlignment.Center,
                    VerticalAlignment = Enum.VerticalAlignment.Center,
                    SortOrder = Enum.SortOrder.LayoutOrder
                }),
                PrimaryText = v2.createElement("TextLabel", {
                    AutomaticSize = Enum.AutomaticSize.XY,
                    Text = v9.statusPrimaryText,
                    Font = l_mapTypographyVariantToFontEnum_0(v10.Semantic.Typography.Title),
                    LayoutOrder = 1,
                    TextColor3 = v10.Semantic.Color.Text.Emphasis.Color3,
                    TextTransparency = v10.Semantic.Color.Text.Emphasis.Transparency,
                    TextSize = v10.Semantic.Typography.Title.FontSize,
                    TextWrapped = true,
                    TextXAlignment = Enum.TextXAlignment.Center,
                    Size = UDim2.new(1, 0, 0, v10.Semantic.Typography.Title.FontSize),
                    BackgroundTransparency = v10.Global.Opacity_0
                }, {
                    Padding = v2.createElement("UIPadding", {
                        PaddingBottom = UDim.new(0, v10.Global.Space_200)
                    })
                }),
                SecondaryText = v2.createElement("TextLabel", {
                    AutomaticSize = Enum.AutomaticSize.XY,
                    Text = v9.statusSecondaryText,
                    Font = l_mapTypographyVariantToFontEnum_0(v10.Semantic.Typography.Header),
                    LayoutOrder = 2,
                    TextColor3 = v10.Semantic.Color.Text.Default.Color3,
                    TextTransparency = v10.Semantic.Color.Text.Emphasis.Transparency,
                    TextSize = v10.Semantic.Typography.Header.FontSize,
                    TextWrapped = true,
                    TextXAlignment = Enum.TextXAlignment.Center,
                    Size = UDim2.new(1, 0, 0, v10.Semantic.Typography.Header.FontSize),
                    BackgroundTransparency = v10.Global.Opacity_0
                })
            }) else nil else v2.createElement("TextLabel", {
                Position = UDim2.new(0, 0, 1, -v10.Semantic.Typography.Subheader.FontSize - v10.Global.Size_150),
                Text = v11.statusPrimaryText,
                Font = l_mapTypographyVariantToFontEnum_0(v10.Semantic.Typography.Body),
                TextColor3 = v9.color,
                TextSize = v10.Semantic.Typography.Body.FontSize,
                Size = UDim2.new(1, 0, 0, v10.Semantic.Typography.Subheader.FontSize),
                BackgroundTransparency = v10.Global.Opacity_0,
                TextXAlignment = Enum.TextXAlignment.Left
            })
        });
    end);
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local l_UserInputService_0 = game:GetService("UserInputService");
local v3 = require(l_CorePackages_0.Packages.React);
local v4 = require(l_CorePackages_0.Workspace.Packages.SharedFlags);
local v5 = require(l_CorePackages_0.UIBlox);
local l_FullPageModal_0 = v5.App.Dialog.Modal.FullPageModal;
local l_ButtonType_0 = v5.App.Button.Enum.ButtonType;
local v8 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportListTable);
local v9 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportSummaryPage);
local _ = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportTypes);
local v11 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportDialogBodyLoading);
local v12 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportTargetComponent);
local v13 = require(l_Modules_0.LuaApp.Components.AbuseReporting.ReportDataFetchStatusMessage);
local v14 = require(l_Modules_0.LuaApp.Components.AbuseReporting.Constants);
local l_useDesignTokens_0 = require(l_CorePackages_0.Workspace.Packages.Style).useDesignTokens;
local l_useDispatch_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).Hooks.RoactRodux.useDispatch;
local l_useSelector_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).Hooks.RoactRodux.useSelector;
local l_withLocalization_0 = require(l_CorePackages_0.Workspace.Packages.Localization).withLocalization;
local l_useScreenSize_0 = require(l_CorePackages_0.Workspace.Packages.RobloxAppHooks).useScreenSize;
local l_isSelectedDataDSAIllegalContent_0 = require(l_CorePackages_0.Workspace.Packages.DsaIllegalContentReporting).isSelectedDataDSAIllegalContent;
local v21 = require(script.Parent.getThumbnailData);
local l_VRConstants_0 = require(l_CorePackages_0.Workspace.Packages.VrCompatibility).VRConstants;
local _ = v5.App.Loading.ShimmerPanel;
local _ = require(l_CorePackages_0.Workspace.Packages.Style).mapTypographyVariantToFontEnum;
local l_isShowEUDSAIllegalContentReportingLink_0 = require(l_CorePackages_0.Workspace.Packages.DsaIllegalContentReporting).isShowEUDSAIllegalContentReportingLink;
local l_GetFFlagLuafiedReportThumbnail_0 = v4.GetFFlagLuafiedReportThumbnail;
local l_GetFFlagLuafiedReportErrorStates_0 = v4.GetFFlagLuafiedReportErrorStates;
local l_GetFFlagLuaAppNewStreamNotificationsEnabled_0 = v4.GetFFlagLuaAppNewStreamNotificationsEnabled;
local l_GetFFlagDSAIllegalContentReporting_0 = v4.GetFFlagDSAIllegalContentReporting;
local l_GetFFlagDSAVRSkipFrontendGeoCheck_0 = v4.GetFFlagDSAVRSkipFrontendGeoCheck;
local function _(v31)
    return l_GetFFlagLuafiedReportErrorStates_0() and v31.loadingState.BEDUILoading;
end;
local function _(v33)
    return l_GetFFlagLuafiedReportErrorStates_0() and v33.loadingState.BEDUIError;
end;
local function v42(v35, v36, v37, v38, v39, v40)
    local v41 = {};
    if v38 then
        table.insert(v41, {
            buttonType = l_ButtonType_0.Secondary,
            props = {
                onActivated = function()
                    v35.onBack();
                end,
                text = v36
            }
        });
    end;
    if v40 then
        table.insert(v41, {
            buttonType = l_ButtonType_0.PrimarySystem,
            props = {
                onActivated = function()
                    v35.onClose();
                end,
                text = v37
            }
        });
    end;
    if v39 then
        table.insert(v41, {
            buttonType = l_ButtonType_0.PrimarySystem,
            props = {
                onActivated = function()
                    v35.onSubmitReport();
                end,
                text = not not v35.BEDUIComponents and v35.BEDUIComponents.submission.buttonText or "",
                isDisabled = v35.loadingState.submitLoading
            }
        });
    end;
    return v41;
end;
local function _(v43, v44)
    if not v43.loadingState.submitLoading and not v43.loadingState.BEDUILoading then
        return v44.Semantic.Color.Action.Alert.Content.Color3;
    else
        return v44.Semantic.Color.Text.Default.Color3;
    end;
end;
return function(v46)
    local v47 = l_useDesignTokens_0();
    local _ = l_useDispatch_0();
    local v49 = nil;
    if l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() then
        v49 = l_useScreenSize_0();
    end;
    local v50 = false;
    local v51 = false;
    if v46.BEDUIComponents ~= nil then
        v51 = false;
        if v46.BEDUIComponents.submission.text ~= nil then
            v51 = l_isSelectedDataDSAIllegalContent_0(v46.selectionData);
        end;
    end;
    v50 = if not l_GetFFlagDSAVRSkipFrontendGeoCheck_0() then v51 and l_isShowEUDSAIllegalContentReportingLink_0() else v51 and l_GetFFlagDSAIllegalContentReporting_0();
    local v52 = l_useSelector_0(v21({
        reportData = v46.reportData
    }));
    local v53 = false;
    if #v46.prevListNodes > 0 then
        v53 = not (l_GetFFlagLuafiedReportErrorStates_0() and v46.loadingState.BEDUIError);
    end;
    local v54 = false;
    if v46.currentList == nil then
        v54 = false;
        if #v46.selectionData > 0 then
            v54 = not v50;
        end;
    end;
    local v55 = l_GetFFlagLuafiedReportErrorStates_0() and v46.loadingState.BEDUIError;
    local v56 = if v46.loadingState.submitLoading or v46.loadingState.BEDUILoading then v47.Semantic.Color.Text.Default.Color3 else v47.Semantic.Color.Action.Alert.Content.Color3;
    return l_withLocalization_0({
        backButtonText = "CommonUI.Controls.Action.Back",
        closeButtonText = "Feature.Friends.Action.Close"
    })(function(v57)
        return v3.createElement(l_FullPageModal_0, {
            distanceFromTop = if not not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() and l_UserInputService_0.StatusBarSize then l_UserInputService_0.StatusBarSize.Y else 0,
            title = not not v46.BEDUIComponents and v46.BEDUIComponents.title.text or "",
            screenSize = if (not not l_GetFFlagLuaAppNewStreamNotificationsEnabled_0() and v46.reportSurface ~= v14.BEDUI_SURFACES.VR) and v49 then v49 else l_VRConstants_0.MainScreenResolution,
            buttonStackProps = if (v53 or v54) or v55 then {
                forcedFillDirection = Enum.FillDirection.Horizontal,
                buttons = v42(v46, v57.backButtonText, v57.closeButtonText, v53, v54, v55)
            } else nil,
            onCloseClicked = function()
                v46.onClose();
                v46.onLogAbandon();
            end
        }, {
            ViewFrame = v3.createElement("Frame", {
                Size = UDim2.new(1, 0, 1, 0),
                BackgroundTransparency = v47.Global.Opacity_0
            }, {
                Layout = v3.createElement("UIListLayout", {
                    FillDirection = Enum.FillDirection.Vertical,
                    HorizontalAlignment = Enum.HorizontalAlignment.Center,
                    SortOrder = Enum.SortOrder.LayoutOrder
                }),
                ReportTarget = if not l_GetFFlagLuafiedReportThumbnail_0() or l_GetFFlagLuafiedReportErrorStates_0() and v46.loadingState.BEDUIError then nil else v3.createElement(v12, {
                    primaryText = v52.primaryText,
                    secondaryText = v52.secondaryText,
                    thumbnailUrl = v52.thumbnailUrl
                }),
                ReportContent = v3.createElement("Frame", {
                    Size = UDim2.new(1, 0, 1, (l_GetFFlagLuafiedReportErrorStates_0() and v46.loadingState.BEDUIError) and 0 or -v47.Global.Size_1400),
                    BackgroundTransparency = v47.Global.Opacity_0,
                    LayoutOrder = 2
                }, {
                    ReportCategoryTable = if not v46.currentList then if #v46.selectionData > 0 then v3.createElement(v9, {
                        heading = not not v46.BEDUIComponents and v46.BEDUIComponents.submission.heading or "",
                        selectionData = v46.selectionData,
                        dsaText = not not v46.BEDUIComponents and v46.BEDUIComponents.submission.text or "",
                        onSummaryPageMounted = v46.onSummaryPageMounted
                    }) else if not (l_GetFFlagLuafiedReportErrorStates_0() and v46.loadingState.BEDUILoading) then nil else v3.createElement(v11, {}) else v3.createElement(v8, {
                        currentList = v46.currentList,
                        onSelect = v46.onSelect
                    }),
                    ReportDataFetchStatusMessage = if not l_GetFFlagLuafiedReportErrorStates_0() then nil else v3.createElement(v13, {
                        statusPrimaryText = v46.loadingState.statusPrimaryText,
                        statusSecondaryText = v46.loadingState.statusSecondaryText,
                        BEDUIError = v46.loadingState.BEDUIError,
                        submitError = v46.loadingState.submitError,
                        color = v56
                    })
                })
            })
        });
    end);
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Packages.React);
local v2 = require(l_CorePackages_0.UIBlox);
local l_useDesignTokens_0 = require(l_CorePackages_0.Workspace.Packages.Style).useDesignTokens;
local l_ShimmerPanel_0 = v2.App.Loading.ShimmerPanel;
return function()
    local v5 = l_useDesignTokens_0();
    local v6 = {
        Padding = v1.createElement("UIPadding", {
            PaddingTop = UDim.new(0, v5.Global.Space_400),
            PaddingBottom = UDim.new(0, v5.Global.Space_300)
        })
    };
    for v7 = 1, 6 do
        v6[#v6 + 1] = v1.createElement(l_ShimmerPanel_0, {
            Size = UDim2.new(1, 0, 0, 30),
            Position = UDim2.new(0, 0, 0, (v7 - 1) * 45),
            shimmerSpeed = 1.5
        });
    end;
    return v1.createElement("Frame", {
        Size = UDim2.new(1, 0, 1, 0),
        BackgroundTransparency = v5.Global.Opacity_0
    }, v6);
end;