local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local l_UserInputService_0 = game:GetService("UserInputService");
local v3 = require(l_CorePackages_0.Roact);
local v4 = require(l_CorePackages_0.RoactRodux);
local v5 = require(l_CorePackages_0.Packages.RoactGamepad);
local v6 = require(l_CorePackages_0.Packages.t);
local v7 = require(l_CorePackages_0.UIBlox);
local l_InteractiveAlert_0 = v7.App.Dialog.Alert.InteractiveAlert;
local _ = v7.App.Button.Enum.ButtonType;
local l_ImageSetLabel_0 = v7.Core.ImageSet.ImageSetLabel;
local l_withStyle_0 = v7.Style.withStyle;
local l_Images_0 = v7.App.ImageSet.Images;
local v13 = require(l_CoreGui_0:WaitForChild("RobloxGui").Modules.RobloxTranslator);
local l_ExternalEventConnection_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).ExternalEventConnection;
local v15 = l_Images_0["component_assets/circle_17_stroke_1"];
local v16 = Rect.new(8, 8, 8, 8);
local v17 = v3.PureComponent:extend("PromptWithTextField");
v17.validateProps = v6.strictInterface({
    fieldText = v6.string,
    onFieldTextUpdated = v6.callback,
    title = v6.string,
    bodyText = v6.optional(v6.string),
    buttonStackInfo = v6.table,
    screenSize = v6.Vector2
});
v17.init = function(v18)
    v18:setState({
        alertPosition = UDim2.fromScale(0.5, 0.5)
    });
    v18.textBoxRef = v3.createRef();
    v18.textUpdated = function(v19)
        v18.props.onFieldTextUpdated(v19.Text);
    end;
    v18.lastAlertHeight = 100;
    v18.calculateAlertPosition = function()
        local v20 = UDim2.fromScale(0.5, 0.5);
        if l_UserInputService_0.OnScreenKeyboardVisible then
            local v21 = (v18.props.screenSize.Y - l_UserInputService_0.OnScreenKeyboardSize.Y) / 2;
            local v22 = v21 - v18.lastAlertHeight / 2;
            if v22 < 20 then
                v21 = v21 + (20 - v22);
            end;
            v20 = UDim2.new(0.5, 0, 0, v21);
        end;
        if v18.state.alertPosition ~= v20 then
            v18:setState({
                alertPosition = v20
            });
        end;
    end;
    v18.alertSizeChanged = function(v23)
        v18.lastAlertHeight = v23.AbsoluteSize.Y;
        v18.calculateAlertPosition();
    end;
    v18.alertMounted = function()
        local v24 = v18.textBoxRef:getValue();
        if v24 then
            v24:CaptureFocus();
        end;
    end;
end;
v17.renderAlertMiddleContent = function(v25)
    return l_withStyle_0(function(v26)
        local l_Font_0 = v26.Font;
        local l_Theme_0 = v26.Theme;
        return v3.createElement("Frame", {
            BackgroundTransparency = 1,
            Size = UDim2.new(1, 0, 0, 35),
            Position = UDim2.fromScale(0, 1),
            AnchorPoint = Vector2.new(0, 1)
        }, {
            TextboxBorder = v3.createElement(l_ImageSetLabel_0, {
                BackgroundTransparency = 1,
                Image = v15,
                ImageColor3 = l_Theme_0.UIDefault.Color,
                ImageTransparency = l_Theme_0.UIDefault.Transparency,
                LayoutOrder = 3,
                ScaleType = Enum.ScaleType.Slice,
                Size = UDim2.new(1, 0, 1, -5),
                Position = UDim2.fromScale(0, 1),
                AnchorPoint = Vector2.new(0, 1),
                SliceCenter = v16
            }, {
                Textbox = v3.createElement(v5.Focusable.TextBox, {
                    BackgroundTransparency = 1,
                    ClearTextOnFocus = false,
                    Font = l_Font_0.Header2.Font,
                    TextSize = l_Font_0.BaseSize * l_Font_0.CaptionBody.RelativeSize,
                    PlaceholderColor3 = l_Theme_0.TextDefault.Color,
                    PlaceholderText = v13:FormatByKey("CoreScripts.AvatarEditorPrompts.OutfitNamePlaceholder"),
                    Position = UDim2.new(0, 6, 0, 0),
                    Size = UDim2.new(1, -12, 1, 0),
                    TextColor3 = l_Theme_0.TextEmphasis.Color,
                    TextTruncate = Enum.TextTruncate.AtEnd,
                    Text = v25.props.fieldText,
                    TextWrapped = true,
                    TextXAlignment = Enum.TextXAlignment.Left,
                    OverlayNativeInput = true,
                    [v3.Change.Text] = v25.textUpdated,
                    [v3.Ref] = v25.textBoxRef
                })
            })
        });
    end);
end;
v17.render = function(v29)
    return v3.createFragment({
        InteractiveAlert = v3.createElement(l_InteractiveAlert_0, {
            title = v29.props.title,
            bodyText = v29.props.bodyText,
            buttonStackInfo = v29.props.buttonStackInfo,
            position = v29.state.alertPosition,
            screenSize = v29.props.screenSize,
            middleContent = function()
                return v29:renderAlertMiddleContent();
            end,
            isMiddleContentFocusable = true,
            onAbsoluteSizeChanged = v29.alertSizeChanged,
            onMounted = v29.alertMounted
        }),
        OnScreenKeyboardVisibleConnection = v3.createElement(l_ExternalEventConnection_0, {
            event = l_UserInputService_0:GetPropertyChangedSignal("OnScreenKeyboardVisible"),
            callback = v29.calculateAlertPosition
        }),
        OnScreenKeyboardSizeConnection = v3.createElement(l_ExternalEventConnection_0, {
            event = l_UserInputService_0:GetPropertyChangedSignal("OnScreenKeyboardSize"),
            callback = v29.calculateAlertPosition
        })
    });
end;
v17.didMount = function(v30)
    v30.calculateAlertPosition();
end;
return v4.connect(function(v31)
    return {
        screenSize = v31.screenSize
    };
end, nil)(v17);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local v5 = require(l_CorePackages_0.UIBlox);
local l_ButtonType_0 = v5.App.Button.Enum.ButtonType;
local l_InteractiveAlert_0 = v5.App.Dialog.Alert.InteractiveAlert;
local v8 = require(l_CoreGui_0:WaitForChild("RobloxGui").Modules.RobloxTranslator);
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v11 = require(l_Parent_0.Prompts.PromptWithTextField);
local v12 = require(l_Parent_1.Thunks.SignalRenameOutfitPermissionDenied);
local v13 = require(l_Parent_1.Thunks.PerformRenameOutfit);
local v14 = require(l_Parent_1.AvatarEditorPromptsPolicy);
local v15 = v2.PureComponent:extend("RenameOutfitNamePrompt");
v15.validateProps = v4.strictInterface({
    outfitId = v4.integer,
    outfitName = v4.string,
    screenSize = v4.Vector2,
    signalRenameOutfitPermissionDenied = v4.callback,
    performRenameOutfit = v4.callback,
    showCustomOutfitNames = v4.boolean
});
v15.init = function(v16)
    v16:setState({
        outfitName = "",
        alertPosition = UDim2.fromScale(0.5, 0.5)
    });
    v16.textUpdated = function(v17)
        v16:setState({
            outfitName = v17
        });
    end;
    v16.confirmRenameOutfit = function()
        v16.props.performRenameOutfit(v16.state.outfitName);
    end;
end;
v15.render = function(v18)
    if v18.props.showCustomOutfitNames then
        return v2.createElement(v11, {
            fieldText = v18.state.outfitName,
            onFieldTextUpdated = v18.textUpdated,
            title = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.RenameOutfitNamePromptTitle"),
            bodyText = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.RenameOutfitPromptText", {
                RBX_NAME = v18.props.outfitName
            }),
            buttonStackInfo = {
                buttons = {
                    {
                        props = {
                            onActivated = v18.props.signalRenameOutfitPermissionDenied,
                            text = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.EnterOutfitNamePromptNo")
                        },
                        isDefaultChild = true
                    },
                    {
                        buttonType = l_ButtonType_0.PrimarySystem,
                        props = {
                            isDisabled = v18.state.outfitName == "",
                            onActivated = v18.confirmRenameOutfit,
                            text = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.EnterOutfitNamePromptYes")
                        },
                        isDefaultChild = false
                    }
                }
            }
        });
    else
        return v2.createElement(l_InteractiveAlert_0, {
            title = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.DisabledRenameOutfitPromptTitle"),
            bodyText = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.DisabledRenameOutfitPromptText"),
            buttonStackInfo = {
                buttons = {
                    {
                        buttonType = l_ButtonType_0.PrimarySystem,
                        props = {
                            onActivated = v18.props.signalRenameOutfitPermissionDenied,
                            text = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.DisabledRenameOutfitPromptOkay")
                        },
                        isDefaultChild = true
                    }
                }
            },
            position = UDim2.fromScale(0.5, 0.5),
            screenSize = v18.props.screenSize,
            isMiddleContentFocusable = false
        });
    end;
end;
return (v14.connect(function(v19, _)
    return {
        showCustomOutfitNames = v19.getCustomOutfitNames()
    };
end)((v3.connect(function(v21)
    return {
        outfitId = v21.promptInfo.outfitId,
        outfitName = v21.promptInfo.outfitName,
        screenSize = v21.screenSize
    };
end, function(v22)
    return {
        signalRenameOutfitPermissionDenied = function()
            return v22(v12);
        end,
        performRenameOutfit = function(v23)
            return v22(v13(v23));
        end
    };
end)(v15))));


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local v5 = require(l_CorePackages_0.UIBlox);
local l_InteractiveAlert_0 = v5.App.Dialog.Alert.InteractiveAlert;
local l_ButtonType_0 = v5.App.Button.Enum.ButtonType;
local v8 = require(l_CoreGui_0:WaitForChild("RobloxGui").Modules.RobloxTranslator);
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v11 = require(l_Parent_0.HumanoidViewport);
local v12 = require(l_Parent_0.ItemsList);
local v13 = require(l_Parent_1.Thunks.SignalSaveAvatarPermissionDenied);
local v14 = require(l_Parent_1.Thunks.PerformSaveAvatar);
local v15 = require(l_Parent_1.GetConformedHumanoidDescription);
local v16 = v2.PureComponent:extend("SaveAvatarPrompt");
v16.validateProps = v4.strictInterface({
    gameName = v4.string,
    screenSize = v4.Vector2,
    humanoidDescription = v4.instanceOf("HumanoidDescription"),
    rigType = v4.enum(Enum.HumanoidRigType),
    performSaveAvatar = v4.callback,
    signalSaveAvatarPermissionDenied = v4.callback
});
v16.init = function(v17)
    v17.mounted = false;
    v17:setState({
        conformedHumanoidDescription = nil,
        getConformedDescriptionFailed = false,
        itemListScrollable = false
    });
    v17.middleContentRef = v2.createRef();
    local v18, v19 = v2.createBinding(UDim2.new(1, 0, 0, 200));
    v17.contentSize = v18;
    v17.updateContentSize = v19;
    v17.onAlertSizeChanged = function(v20)
        local l_AbsoluteSize_0 = v20.AbsoluteSize;
        if v17.middleContentRef:getValue() then
            local l_Y_0 = v17.middleContentRef:getValue().AbsoluteSize.Y;
            local v23 = (v17.props.screenSize.Y - 60) - (l_AbsoluteSize_0.Y - l_Y_0);
            local v24 = (v17.middleContentRef:getValue().AbsoluteSize.X / 2 - 10) + 80;
            if v24 < v23 then
                v23 = v24;
            end;
            if l_Y_0 ~= v23 then
                v17.updateContentSize(UDim2.new(1, 0, 0, v23));
            end;
            return ;
        else
            return ;
        end;
    end;
    v17.itemListScrollableUpdated = function(v25, v26)
        if v26 == v17.contentSize:getValue().Y.Offset then
            v17:setState({
                itemListScrollable = v25
            });
        end;
    end;
    v17.retryLoadDescription = function()
        v17:setState({
            getConformedDescriptionFailed = false
        });
        v17:getConformedHumanoidDescription();
    end;
    v17.renderAlertMiddleContent = function()
        local l_conformedHumanoidDescription_0 = v17.state.conformedHumanoidDescription;
        local l_getConformedDescriptionFailed_0 = v17.state.getConformedDescriptionFailed;
        return v2.createElement("Frame", {
            BackgroundTransparency = 1,
            Size = v17.contentSize,
            [v2.Ref] = v17.middleContentRef
        }, {
            ItemsListFrame = v2.createElement("Frame", {
                BackgroundTransparency = 1,
                Size = UDim2.fromScale(0.45, 1)
            }, {
                ItemsList = v2.createElement(v12, {
                    humanoidDescription = l_conformedHumanoidDescription_0,
                    retryLoadDescription = v17.retryLoadDescription,
                    loadingFailed = l_getConformedDescriptionFailed_0,
                    itemListScrollableUpdated = v17.itemListScrollableUpdated
                })
            }),
            HumanoidViewportFrame = v2.createElement("Frame", {
                BackgroundTransparency = 1,
                Size = UDim2.fromScale(0.55, 1),
                Position = UDim2.fromScale(0.45, 0),
                LayoutOrder = 2
            }, {
                UIPadding = v2.createElement("UIPadding", {
                    PaddingLeft = UDim.new(0, 5),
                    PaddingRight = UDim.new(0, 5)
                }),
                HumanoidViewport = v2.createElement(v11, {
                    humanoidDescription = l_conformedHumanoidDescription_0,
                    loadingFailed = l_getConformedDescriptionFailed_0,
                    retryLoadDescription = v17.retryLoadDescription,
                    rigType = v17.props.rigType
                })
            }),
            UISizeConstraint = v2.createElement("UISizeConstraint", {
                MaxSize = v17.contentMaxSize
            })
        });
    end;
end;
v16.render = function(v29)
    return v2.createElement(l_InteractiveAlert_0, {
        title = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.SaveAvatarPromptTitle"),
        bodyText = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.SaveAvatarPromptText", {
            RBX_NAME = v29.props.gameName
        }),
        buttonStackInfo = {
            buttons = {
                {
                    props = {
                        onActivated = v29.props.signalSaveAvatarPermissionDenied,
                        text = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.SaveAvatarPromptNo")
                    },
                    isDefaultChild = true
                },
                {
                    buttonType = l_ButtonType_0.PrimarySystem,
                    props = {
                        onActivated = v29.props.performSaveAvatar,
                        text = v8:FormatByKey("CoreScripts.AvatarEditorPrompts.SaveAvatarPromptYes")
                    },
                    isDefaultChild = false
                }
            }
        },
        position = UDim2.fromScale(0.5, 0.5),
        screenSize = v29.props.screenSize,
        middleContent = v29.renderAlertMiddleContent,
        onAbsoluteSizeChanged = v29.onAlertSizeChanged,
        isMiddleContentFocusable = v29.state.itemListScrollable
    });
end;
v16.getConformedHumanoidDescription = function(v30, v31)
    v15(v31, true):andThen(function(v32)
        if v30.mounted then
            v30:setState({
                conformedHumanoidDescription = v32
            });
            return ;
        else
            return ;
        end;
    end, function(_)
        if v30.mounted then
            v30:setState({
                getConformedDescriptionFailed = true
            });
            return ;
        else
            return ;
        end;
    end);
end;
v16.didMount = function(v34)
    v34.mounted = true;
    v34:getConformedHumanoidDescription(v34.props.humanoidDescription);
end;
v16.didUpdate = function(v35, v36, _)
    if v35.props.humanoidDescription ~= v36.humanoidDescription then
        v35:setState({
            conformedHumanoidDescription = v2.None,
            getConformedDescriptionFailed = false
        });
        v35:getConformedHumanoidDescription(v35.props.humanoidDescription);
    end;
end;
v16.willUnmount = function(v38)
    v38.mounted = false;
end;
return v3.connect(function(v39)
    return {
        gameName = v39.gameName,
        screenSize = v39.screenSize,
        humanoidDescription = v39.promptInfo.humanoidDescription,
        rigType = v39.promptInfo.rigType
    };
end, function(v40)
    return {
        signalSaveAvatarPermissionDenied = function()
            return v40(v13);
        end,
        performSaveAvatar = function()
            return v40(v14);
        end
    };
end)(v16);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local v5 = require(l_CorePackages_0.UIBlox);
local v6 = require(l_CoreGui_0:WaitForChild("RobloxGui").Modules.RobloxTranslator);
local l_InteractiveAlert_0 = v5.App.Dialog.Alert.InteractiveAlert;
local l_ButtonType_0 = v5.App.Button.Enum.ButtonType;
local l_LoadableImage_0 = v5.App.Loading.LoadableImage;
local l_Parent_0 = script.Parent.Parent.Parent;
local v11 = require(l_Parent_0.Thunks.PerformSetFavorite);
local v12 = require(l_Parent_0.Thunks.SignalSetFavoritePermissionDenied);
local v13 = v2.PureComponent:extend("SetFavoritePrompt");
v13.validateProps = v4.strictInterface({
    itemId = v4.integer,
    itemType = v4.enum(Enum.AvatarItemType),
    itemName = v4.string,
    shouldFavorite = v4.boolean,
    screenSize = v4.Vector2,
    performSetFavorite = v4.callback,
    signalSetFavoritePermissionDenied = v4.callback
});
v13.init = function(v14)
    v14.renderAlertMiddleContent = function()
        local v15 = nil;
        if v14.props.itemType == Enum.AvatarItemType.Asset then
            v15 = "Asset";
        elseif v14.props.itemType == Enum.AvatarItemType.Bundle then
            v15 = "BundleThumbnail";
        end;
        return v2.createElement("Frame", {
            BackgroundTransparency = 1,
            Size = UDim2.new(1, 0, 0, 150)
        }, {
            Thumnail = v2.createElement(l_LoadableImage_0, {
                Position = UDim2.fromScale(0.5, 0),
                AnchorPoint = Vector2.new(0.5, 0),
                Size = UDim2.fromOffset(150, 150),
                BackgroundTransparency = 1,
                Image = "rbxthumb://type=" .. v15 .. "&id=" .. v14.props.itemId .. "&w=150&h=150",
                useShimmerAnimationWhileLoading = true,
                showFailedStateWhenLoadingFailed = true
            })
        });
    end;
end;
v13.render = function(v16)
    local v17 = nil;
    local v18 = nil;
    if not v16.props.shouldFavorite then
        v17 = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.UnfavouriteItemPromptTitle");
        v18 = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.UnfavouriteItemPromptText", {
            RBX_NAME = v16.props.itemName
        });
    else
        v17 = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.FavouriteItemPromptTitle");
        v18 = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.FavouriteItemPromptText", {
            RBX_NAME = v16.props.itemName
        });
    end;
    return v2.createElement(l_InteractiveAlert_0, {
        title = v17,
        bodyText = v18,
        buttonStackInfo = {
            buttons = {
                {
                    props = {
                        onActivated = v16.props.signalSetFavoritePermissionDenied,
                        text = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.FavouriteItemPromptNo")
                    },
                    isDefaultChild = true
                },
                {
                    buttonType = l_ButtonType_0.PrimarySystem,
                    props = {
                        onActivated = v16.props.performSetFavorite,
                        text = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.FavouriteItemPromptYes")
                    },
                    isDefaultChild = false
                }
            }
        },
        position = UDim2.fromScale(0.5, 0.5),
        screenSize = v16.props.screenSize,
        middleContent = v16.renderAlertMiddleContent,
        isMiddleContentFocusable = false
    });
end;
return v3.connect(function(v19)
    return {
        itemId = v19.promptInfo.itemId,
        itemType = v19.promptInfo.itemType,
        itemName = v19.promptInfo.itemName,
        shouldFavorite = v19.promptInfo.shouldFavorite,
        screenSize = v19.screenSize
    };
end, function(v20)
    return {
        performSetFavorite = function()
            return v20(v11);
        end,
        signalSetFavoritePermissionDenied = function()
            return v20(v12);
        end
    };
end)(v13);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local l_ButtonType_0 = require(l_CorePackages_0.UIBlox).App.Button.Enum.ButtonType;
local v6 = require(l_CoreGui_0:WaitForChild("RobloxGui").Modules.RobloxTranslator);
local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v9 = require(l_Parent_1.Thunks.SignalUpdateOutfitPermissionDenied);
local v10 = require(l_Parent_1.Thunks.PerformUpdateOutfit);
local v11 = require(l_Parent_0.Prompts.PromptWithAvatarViewport);
local v12 = require(l_Parent_1.AvatarEditorPromptsPolicy);
local v13 = v2.PureComponent:extend("UpdateOutfitPrompt");
v13.validateProps = v4.strictInterface({
    screenSize = v4.Vector2,
    humanoidDescription = v4.instanceOf("HumanoidDescription"),
    rigType = v4.enum(Enum.HumanoidRigType),
    outfitName = v4.string,
    signalUpdateOutfitPermissionDenied = v4.callback,
    performUpdateOutfit = v4.callback,
    showCustomOutfitNames = v4.boolean
});
v13.render = function(v14)
    local _ = nil;
    return v2.createElement(v11, {
        humanoidDescription = v14.props.humanoidDescription,
        rigType = v14.props.rigType,
        title = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.UpdateOutfitPromptTitle"),
        bodyText = if not v14.props.showCustomOutfitNames then v6:FormatByKey("CoreScripts.AvatarEditorPrompts.UpdateOutfitPromptTextNoOutfitName") else v6:FormatByKey("CoreScripts.AvatarEditorPrompts.UpdateOutfitPromptText", {
            RBX_NAME = v14.props.outfitName
        }),
        buttonStackInfo = {
            buttons = {
                {
                    props = {
                        onActivated = v14.props.signalUpdateOutfitPermissionDenied,
                        text = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.UpdateOutfitPromptNo")
                    },
                    isDefaultChild = true
                },
                {
                    buttonType = l_ButtonType_0.PrimarySystem,
                    props = {
                        onActivated = v14.props.performUpdateOutfit,
                        text = v6:FormatByKey("CoreScripts.AvatarEditorPrompts.UpdateOutfitPromptYes")
                    },
                    isDefaultChild = false
                }
            }
        }
    });
end;
return (v12.connect(function(v16, _)
    return {
        showCustomOutfitNames = v16.getCustomOutfitNames()
    };
end)((v3.connect(function(v18)
    return {
        screenSize = v18.screenSize,
        humanoidDescription = v18.promptInfo.humanoidDescription,
        rigType = v18.promptInfo.rigType,
        outfitName = v18.promptInfo.outfitName
    };
end, function(v19)
    return {
        signalUpdateOutfitPermissionDenied = function()
            return v19(v9);
        end,
        performUpdateOutfit = function()
            return v19(v10);
        end or nil
    };
end)(v13))));


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_Parent_0 = script.Parent;
local v2 = require(l_Parent_0.Actions.OpenPrompt);
local v3 = require(l_Parent_0.PromptType);
local v4 = require(l_Parent_0.Thunks.OpenSetFavoritePrompt);
local v5 = require(l_Parent_0.Thunks.OpenSaveAvatarPrompt);
local v6 = require(l_Parent_0.Thunks.OpenDeleteOutfitPrompt);
local v7 = require(l_Parent_0.Thunks.OpenRenameOutfitPrompt);
local v8 = require(l_Parent_0.Thunks.OpenUpdateOutfitPrompt);
return function(v9)
    local v10 = {};
    table.insert(v10, l_AvatarEditorService_0.OpenPromptSaveAvatar:Connect(function(v11, v12)
        v9:dispatch(v5(v11, v12));
    end));
    table.insert(v10, l_AvatarEditorService_0.OpenAllowInventoryReadAccess:Connect(function()
        v9:dispatch(v2(v3.AllowInventoryReadAccess, {}));
    end));
    table.insert(v10, l_AvatarEditorService_0.OpenPromptCreateOufit:Connect(function(v13, v14)
        v9:dispatch(v2(v3.CreateOutfit, {
            humanoidDescription = v13,
            rigType = v14
        }));
    end));
    table.insert(v10, l_AvatarEditorService_0.OpenPromptSetFavorite:Connect(function(v15, v16, v17)
        v9:dispatch(v4(v15, v16, v17));
    end));
    table.insert(v10, l_AvatarEditorService_0.OpenPromptDeleteOutfit:Connect(function(v18)
        v9:dispatch(v6(v18));
    end));
    table.insert(v10, l_AvatarEditorService_0.OpenPromptRenameOutfit:Connect(function(v19)
        v9:dispatch(v7(v19));
    end));
    table.insert(v10, l_AvatarEditorService_0.OpenPromptUpdateOutfit:Connect(function(v20, v21, v22)
        v9:dispatch(v8(v20, v21, v22));
    end));
    return v10;
end;


local v0 = {
    "ClimbAnimation",
    "Face",
    "FallAnimation",
    "GraphicTShirt",
    "Head",
    "IdleAnimation",
    "JumpAnimation",
    "LeftArm",
    "LeftLeg",
    "Pants",
    "RightArm",
    "RightLeg",
    "RunAnimation",
    "Shirt",
    "SwimAnimation",
    "Torso",
    "WalkAnimation"
};
return function(v1)
    local v2 = {};
    for _, v4 in ipairs(v0) do
        local v5 = v1[v4];
        if typeof(v5) == "number" and v5 > 0 then
            table.insert(v2, v5);
        elseif typeof(v5) == "string" and v5 ~= "" then
            for v6 in v5:gmatch("([%d]+),?") do
                table.insert(v2, (tonumber(v6)));
            end;
        end;
    end;
    for _, v8 in ipairs((v1:GetAccessories(true))) do
        table.insert(v2, v8.AssetId);
    end;
    local l_v1_Emotes_0 = v1:GetEmotes();
    for _, v11 in ipairs((v1:GetEquippedEmotes())) do
        local v12 = l_v1_Emotes_0[v11.Name];
        if v12 then
            for _, v14 in ipairs(v12) do
                table.insert(v2, v14);
            end;
        end;
    end;
    return v2;
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v2 = require(l_CorePackages_0.Promise);
return function(v3)
    return v2.new(function(v4, v5)
        local l_status_0, l_result_0 = pcall(function()
            return l_AvatarEditorService_0:GetBatchItemDetails(v3, Enum.AvatarItemType.Asset);
        end);
        if not l_status_0 then
            v5();
            return ;
        else
            local v8 = {};
            for _, v10 in ipairs(l_result_0) do
                v8[v10.Id] = v10.Name;
            end;
            v4(v8);
            return ;
        end;
    end);
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Cryo);
local _ = require(l_CorePackages_0.Promise);
local v3 = require(script.Parent.GetCurrentHumanoidDescription);
local v4 = require(script.Parent.GetAssetIdsFromDescription);
local v5 = require(script.Parent.GetAssetNamesForIds);
return function(v6)
    local function v13(v7, v8)
        local v9 = v1.List.toSet(v7);
        local v10 = v1.List.toSet(v8);
        return v1.List.filter(v8, function(v11)
            return v9[v11] == nil;
        end), (v1.List.filter(v7, function(v12)
            return v10[v12] == nil;
        end));
    end;
    return v3():andThen(function(v14)
        local v15, v16 = v13(v4(v14), (v4(v6)));
        return v5((v1.List.join(v15, v16))):andThen(function(v17)
            local v18 = {};
            for _, v20 in ipairs(v15) do
                table.insert(v18, v17[v20]);
            end;
            local v21 = {};
            for _, v23 in ipairs(v16) do
                table.insert(v21, v17[v23]);
            end;
            return {
                addedNames = v18,
                removedNames = v21,
                addedAssetIds = v15,
                removedAssetIds = v16
            };
        end);
    end);
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(game:GetService("CorePackages").Promise);
local v2 = nil;
local v3 = nil;
local function v15(v4, v5, v6)
    local l_l_AvatarEditorService_0_AvatarRules_0 = l_AvatarEditorService_0:GetAvatarRules();
    if l_l_AvatarEditorService_0_AvatarRules_0.DefaultClothingAssetLists then
        local l_DefaultShirtAssetIds_0 = l_l_AvatarEditorService_0_AvatarRules_0.DefaultClothingAssetLists.DefaultShirtAssetIds;
        local l_DefaultPantAssetIds_0 = l_l_AvatarEditorService_0_AvatarRules_0.DefaultClothingAssetLists.DefaultPantAssetIds;
        if l_DefaultShirtAssetIds_0 and l_DefaultPantAssetIds_0 then
            local v10 = nil;
            for _, v12 in ipairs(l_DefaultShirtAssetIds_0) do
                if v12 == v4.Shirt then
                    v10 = v10 or v4:Clone();
                    v10.Shirt = 0;
                end;
            end;
            for _, v14 in ipairs(l_DefaultPantAssetIds_0) do
                if v14 == v4.Pants then
                    v10 = v10 or v4:Clone();
                    v10.Pants = 0;
                end;
            end;
            v5(v10 or v4);
            return ;
        else
            v6("No default clothing ids in avatar rules");
            return ;
        end;
    else
        v6("No default clothing in avatar rules");
        return ;
    end;
end;
return function(v16, v17)
    if v16 == v2 then
        if not v17 then
            return v1.new(function(v18, v19)
                v15(v3, v18, v19);
            end);
        else
            return v1.resolve(v3);
        end;
    else
        return v1.new(function(v20, v21)
            coroutine.wrap(function()
                local l_status_0, l_result_0 = pcall(function()
                    return l_AvatarEditorService_0:ConformToAvatarRules(v16);
                end);
                if not l_status_0 then
                    v21(l_result_0);
                    return ;
                else
                    v2 = v16;
                    v3 = l_result_0;
                    if not v17 then
                        v15(l_result_0, v20, v21);
                        return ;
                    else
                        v20(l_result_0);
                        return ;
                    end;
                end;
            end)();
        end);
    end;
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_Players_0 = game:GetService("Players");
local v2 = require(l_CorePackages_0.Promise);
return function()
    return v2.new(function(v3, v4)
        local l_status_0, l_result_0 = pcall(function()
            return l_Players_0:GetHumanoidDescriptionFromUserId(l_Players_0.LocalPlayer.UserId);
        end);
        if not l_status_0 then
            v4();
            return ;
        else
            v3(l_result_0);
            return ;
        end;
    end);
end;


return require(game:GetService("CorePackages").enumerate)("PromptType", {
    "AllowInventoryReadAccess",
    "SaveAvatar",
    "CreateOutfit",
    "EnterOutfitName",
    "SetFavorite",
    "DeleteOutfit",
    "RenameOutfit",
    "UpdateOutfit"
});


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Rodux);
local v2 = require(l_CorePackages_0.Cryo);
local l_Parent_0 = script.Parent.Parent;
return (v1.createReducer({
    addedAssets = nil,
    removedAssets = nil
}, {
    [require(l_Parent_0.Actions.AddAnalyticsInfo).name] = function(v4, v5)
        return v2.Dictionary.join(v4, v5.info);
    end,
    [require(l_Parent_0.Actions.CloseOpenPrompt).name] = function(_, _)
        return {};
    end
}));


return require(game:GetService("CorePackages").Rodux).createReducer(require(game:GetService("CoreGui"):WaitForChild("RobloxGui").Modules.RobloxTranslator):FormatByKey("CoreScripts.AvatarEditorPrompts.GameNamePlaceHolder"), {
    [require(script.Parent.Parent.Actions.GameNameFetched).name] = function(_, v1)
        return v1.gameName;
    end
});


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Rodux);
local v2 = require(l_CorePackages_0.Cryo);
local l_Parent_0 = script.Parent.Parent;
local v4 = require(l_Parent_0.PromptType);
return (v1.createReducer({
    promptType = nil,
    humanoidDescription = nil,
    rigType = nil,
    itemId = nil,
    itemType = nil,
    itemName = nil,
    isFavorited = nil,
    queue = {},
    infoQueue = {}
}, {
    [require(l_Parent_0.Actions.CloseOpenPrompt).name] = function(v5, _)
        if not v2.isEmpty(v5.queue) then
            return v2.Dictionary.join(v5.infoQueue[1], {
                promptType = v5.queue[1],
                queue = v2.List.removeIndex(v5.queue, 1),
                infoQueue = v2.List.removeIndex(v5.infoQueue, 1)
            });
        else
            return {
                queue = v5.queue,
                infoQueue = v5.infoQueue
            };
        end;
    end,
    [require(l_Parent_0.Actions.OpenPrompt).name] = function(v7, v8)
        if v7.promptType == nil then
            return v2.Dictionary.join(v7, {
                promptType = v8.promptType
            }, v8.promptInfo);
        else
            return v2.Dictionary.join(v7, {
                queue = v2.List.join(v7.queue, {
                    v8.promptType
                }),
                infoQueue = v2.List.join(v7.infoQueue, {
                    v8.promptInfo
                })
            });
        end;
    end,
    [require(l_Parent_0.Actions.CreateOutfitConfirmed).name] = function(v9, _)
        return v2.Dictionary.join(v9, {
            promptType = v4.EnterOutfitName
        });
    end
}));


return (require(game:GetService("CorePackages").Rodux).createReducer(Vector2.new(0, 0), {
    [require(script.Parent.Parent.Actions.ScreenSizeUpdated).name] = function(_, v1)
        return v1.screenSize;
    end
}));


return (require(game:GetService("CorePackages").Rodux).combineReducers({
    promptInfo = require(script.PromptInfo),
    screenSize = require(script.ScreenSize),
    gameName = require(script.GameName),
    analyticsInfo = require(script.AnalyticsInfo)
}));


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.CloseOpenPrompt);
local v3 = require(l_Parent_0.PromptType);
return function(v4)
    local l_promptType_0 = v4:getState().promptInfo.promptType;
    if l_promptType_0 == v3.AllowInventoryReadAccess then
        l_AvatarEditorService_0:SetAllowInventoryReadAccess(false);
    elseif l_promptType_0 == v3.SaveAvatar then
        l_AvatarEditorService_0:SignalSaveAvatarPermissionDenied();
    elseif l_promptType_0 == v3.CreateOutfit then
        l_AvatarEditorService_0:SignalCreateOutfitPermissionDenied();
    elseif l_promptType_0 == v3.EnterOutfitName then
        l_AvatarEditorService_0:SignalCreateOutfitPermissionDenied();
    elseif l_promptType_0 == v3.SetFavorite then
        l_AvatarEditorService_0:SignalSetFavoritePermissionDenied();
    elseif l_promptType_0 == v3.DeleteOutfit then
        l_AvatarEditorService_0:SignalDeleteOutfitPermissionDenied();
    elseif l_promptType_0 == v3.RenameOutfit then
        l_AvatarEditorService_0:SignalRenameOutfitPermissionDenied();
    elseif l_promptType_0 == v3.UpdateOutfit then
        l_AvatarEditorService_0:SignalUpdateOutfitPermissionDenied();
    elseif l_promptType_0 ~= nil then
        error("CloseOpenPrompt for unhandled prompt type " .. tostring(l_promptType_0));
    end;
    v4:dispatch(v2());
end;


local l_CoreGui_0 = game:GetService("CoreGui");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_HttpRbxApiService_0 = game:GetService("HttpRbxApiService");
local l_RobloxGui_0 = l_CoreGui_0:WaitForChild("RobloxGui");
local v4 = require(l_CorePackages_0.Promise);
local v5 = require(l_RobloxGui_0.Modules.Common.httpRequest)(l_HttpRbxApiService_0);
local v6 = require(script.Parent.Parent.Actions.GameNameFetched);
local l_GetGameNameAndDescription_0 = require(l_CorePackages_0.Workspace.Packages.GameDetailRodux).GetGameNameAndDescription;
return function(v8)
    if game.GameId == 0 then
        return v4.resolve();
    else
        return l_GetGameNameAndDescription_0(v5, game.GameId):andThen(function(v9)
            v8:dispatch(v6(v9.Name));
            return v9.Name;
        end, function()
            warn("Unable to get game name for Avatar Editor Prompts");
            return v4.reject();
        end);
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local _ = game:GetService("CorePackages");
local _ = game:GetService("HttpRbxApiService");
local l_Parent_0 = script.Parent.Parent;
local v4 = require(l_Parent_0.Actions.OpenPrompt);
local v5 = require(l_Parent_0.Network.GetOutfitName);
local v6 = require(l_Parent_0.PromptType);
return function(v7)
    return function(v8)
        v5(v7):andThen(function(v9)
            v8:dispatch(v4(v6.DeleteOutfit, {
                outfitId = v7,
                outfitName = v9
            }));
        end, function(_)
            l_AvatarEditorService_0:SignalDeleteOutfitFailed();
        end);
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.OpenPrompt);
local v3 = require(l_Parent_0.Network.GetOutfitName);
local v4 = require(l_Parent_0.PromptType);
return function(v5)
    return function(v6)
        v3(v5):andThen(function(v7)
            v6:dispatch(v2(v4.RenameOutfit, {
                outfitId = v5,
                outfitName = v7
            }));
        end, function(_)
            l_AvatarEditorService_0:SignalRenameOutfitFailed();
        end);
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Actions.OpenPrompt);
local v2 = require(l_Parent_0.PromptType);
return function(v3, v4)
    return function(v5)
        v5:dispatch(v1(v2.SaveAvatar, {
            humanoidDescription = v3,
            rigType = v4
        }));
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_MarketplaceService_0 = game:GetService("MarketplaceService");
local v3 = require(l_CorePackages_0.Promise);
local l_Parent_0 = script.Parent.Parent;
local v5 = require(l_Parent_0.Actions.OpenPrompt);
local v6 = require(l_Parent_0.PromptType);
return function(v7, v8, v9)
    return function(v10)
        return v3.new(function(v11, v12)
            local v13 = nil;
            v13 = if v8 == Enum.AvatarItemType.Asset then Enum.InfoType.Asset else Enum.InfoType.Bundle;
            local l_status_0, l_result_0 = pcall(function()
                return l_MarketplaceService_0:GetProductInfo(v7, v13);
            end);
            if not l_status_0 then
                l_AvatarEditorService_0:SignalSetFavoriteFailed();
                v12();
            else
                v10:dispatch(v5(v6.SetFavorite, {
                    itemId = v7,
                    itemName = l_result_0.Name,
                    itemType = v8,
                    shouldFavorite = v9
                }));
                v11();
            end;
        end);
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.OpenPrompt);
local v3 = require(l_Parent_0.Network.GetOutfitName);
local v4 = require(l_Parent_0.PromptType);
return function(v5, v6, v7)
    return function(v8)
        v3(v5):andThen(function(v9)
            v8:dispatch(v2(v4.UpdateOutfit, {
                outfitId = v5,
                outfitName = v9,
                humanoidDescription = v6,
                rigType = v7
            }));
        end, function(_)
            l_AvatarEditorService_0:SignalUpdateOutfitFailed();
        end);
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.CloseOpenPrompt);
local v3 = require(l_Parent_0.GetConformedHumanoidDescription);
return function(v4)
    return function(v5)
        v3(v5:getState().promptInfo.humanoidDescription, false):andThen(function(v6)
            l_AvatarEditorService_0:PerformCreateOutfitWithDescription(v6, v4);
        end, function(_)
            l_AvatarEditorService_0:SignalCreateOutfitFailed();
        end);
        v5:dispatch(v2());
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:PerformDeleteOutfit();
    v2:dispatch(v1());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    return function(v3)
        l_AvatarEditorService_0:PerformRenameOutfit(v2);
        v3:dispatch(v1());
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.CloseOpenPrompt);
local v3 = require(l_Parent_0.GetConformedHumanoidDescription);
return function(v4)
    local v5 = v4:getState().analyticsInfo.addedAssets or {};
    local v6 = v4:getState().analyticsInfo.removedAssets or {};
    v3(v4:getState().promptInfo.humanoidDescription, false):andThen(function(v7)
        l_AvatarEditorService_0:PerformSaveAvatarWithDescription(v7, v5, v6);
    end, function(_)
        l_AvatarEditorService_0:SignalSaveAvatarFailed();
    end);
    v4:dispatch(v2());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:PerformSetFavorite();
    v2:dispatch(v1());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.CloseOpenPrompt);
local v3 = require(l_Parent_0.GetConformedHumanoidDescription);
return function(v4)
    v3(v4:getState().promptInfo.humanoidDescription, false):andThen(function(v5)
        l_AvatarEditorService_0:PerformUpdateOutfit(v5);
    end, function(_)
        l_AvatarEditorService_0:SignalUpdateOutfitFailed();
    end);
    v4:dispatch(v2());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    return function(v3)
        l_AvatarEditorService_0:SetAllowInventoryReadAccess(v2);
        v3:dispatch(v1());
    end;
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:SignalCreateOutfitPermissionDenied();
    v2:dispatch(v1());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:SignalDeleteOutfitPermissionDenied();
    v2:dispatch(v1());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:SignalRenameOutfitPermissionDenied();
    v2:dispatch(v1());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:SignalSaveAvatarPermissionDenied();
    v2:dispatch(v1());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:SignalSetFavoritePermissionDenied();
    v2:dispatch(v1());
end;


local l_AvatarEditorService_0 = game:GetService("AvatarEditorService");
local v1 = require(script.Parent.Parent.Actions.CloseOpenPrompt);
return function(v2)
    l_AvatarEditorService_0:SignalUpdateOutfitPermissionDenied();
    v2:dispatch(v1());
end;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CoreGui_0:WaitForChild("RobloxGui").Modules.Common.renderWithCoreScriptsStyleProvider);
local v3 = require(l_CorePackages_0.Roact);
local v4 = require(l_CorePackages_0.Rodux);
local v5 = require(l_CorePackages_0.RoactRodux);
local _ = require(l_CorePackages_0.UIBlox);
local v7 = require(script.Components.AvatarEditorPromptsApp);
local v8 = require(script.Reducer);
local v9 = require(script.Thunks.GetGameName);
local v10 = require(script.AvatarEditorPromptsPolicy);
local v11 = require(script.RoactGlobalConfig);
local v12 = require(script.ConnectAvatarEditorServiceEvents);
local v13 = {};
v13.__index = v13;
v13.new = function()
    local v14 = setmetatable({}, v13);
    if v11.propValidation then
        v3.setGlobalConfig({
            propValidation = true
        });
    end;
    if v11.elementTracing then
        v3.setGlobalConfig({
            elementTracing = true
        });
    end;
    v14.store = v4.Store.new(v8, nil, {
        v4.thunkMiddleware
    });
    v14.store:dispatch(v9);
    v14.root = v3.createElement(v5.StoreProvider, {
        store = v14.store
    }, {
        PolicyProvider = v3.createElement(v10.Provider, {
            policy = {
                v10.Mapper
            }
        }, {
            ThemeProvider = v2({
                AvatarEditorPromptsApp = v3.createElement(v7)
            })
        })
    });
    v14.element = v3.mount(v14.root, l_CoreGui_0, "AvatarEditorPrompts");
    v14.serviceConnections = v12(v14.store);
    return v14;
end;
return v13.new();


local l_CoreGui_0 = game:GetService("CoreGui");
local l_CorePackages_0 = game:GetService("CorePackages");
local v2 = require(l_CorePackages_0.Cryo);
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v4 = require(l_Modules_0.AvatarExperience.Common.Constants);
local v5 = require(l_Modules_0.AvatarExperience.AvatarEditor.Utils);
local v10 = {
    getEquippedAccessoriesMemoized = require(l_CorePackages_0.Workspace.Packages.AppCommonLib).memoize(function(v6)
        local v7 = {};
        for _, v9 in v4.AccessoryAssetTypes, nil, nil do
            v7 = v2.List.join(v7, v5.getEquippedAssetIdsForType(v6, v9));
        end;
        return v7;
    end)
};
v10.getEquippedAccessories = function(v11)
    return v10.getEquippedAccessoriesMemoized(v11.AvatarExperience.AvatarEditor.Character.EquippedAssets);
end;
return v10;


return require(game:GetService("CorePackages").Rodux).makeActionCreator(script.Name, function(v0, v1, v2)
    return {
        adjustmentSliderType = v0,
        assetId = v1,
        value = v2
    };
end);


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


return require(game:GetService("CorePackages").Rodux).makeActionCreator(script.Name, function(v0, v1, v2, v3)
    return {
        assetId = v0,
        attachmentCFrame = v1,
        accessoryCFrame = v2,
        accessoryScale = v3
    };
end);


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


return require(game:GetService("CorePackages").Rodux).makeActionCreator(script.Name, function(v0, v1, v2)
    return {
        assetId = v0,
        adjustedCFrame = v1,
        adjustedScale = v2
    };
end);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.RoactGamepad);
local v5 = require(l_CorePackages_0.Packages.t);
local l_Focusable_0 = v4.Focusable;
local l_withLocalization_0 = require(l_CorePackages_0.Workspace.Packages.Localization).withLocalization;
local l_withNavigation_0 = require(l_CorePackages_0.RoactNavigation).withNavigation;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local l_RoactServices_0 = require(l_CorePackages_0.Workspace.Packages.RoactServices).RoactServices;
local v11 = require(l_Modules_0.AvatarExperience.Common.Services.Analytics);
local v12 = require(l_Modules_0.LuaApp.Components.TopBar.TopBar);
local v13 = require(l_Modules_0.AvatarExperience.Common.Components.RoactNavigation.AvatarScreen);
local v14 = require(l_Modules_0.AvatarExperience.Common.Thunks.SetFullView);
local v15 = require(l_Modules_0.AvatarExperience.Common.Selectors.selectIsFullView);
local v16 = require(l_Modules_0.AvatarExperience.Common.Utils);
local l_DeviceOrientationMode_0 = require(l_CorePackages_0.Workspace.Packages.RobloxAppEnums).DeviceOrientationMode;
local _ = require(l_Modules_0.AvatarExperience.Common.AvatarExperienceState);
local v19 = require(l_Modules_0.AvatarExperience.Common.Components.Refinement.RefinementNavBar);
local v20 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.VerticalDrawer);
local v21 = require(l_Modules_0.AvatarExperience.Common.Components.GamepadFocusHandlerForPage);
local v22 = v2.PureComponent:extend("AccessoryAdjustmentPage");
v22.validateProps = v5.strictInterface({
    fullView = v5.userdata,
    isPortrait = v5.boolean,
    setFullView = v5.callback,
    avatarExperienceAnalytics = v5.table,
    navigation = v5.table
});
v22.init = function(v23)
    v23.focusController = v4.createFocusController();
    v23.verticalDrawerRef = v2.createRef();
    v23.topBarRef = v2.createRef();
    v23.adjustmentButtonRef = v2.createRef();
    v23.refinementNavBarRef = v2.createRef();
    v23.changeView = function()
        v23.props.setFullView(v23.props.avatarExperienceAnalytics, (v16.getNewFullViewEnum(v23.props.fullView)));
    end;
    v23.backButtonComponent = v12.makeBackButton(function()
        v23.props.navigation.pop();
    end);
end;
v22.renderTopBar = function(v24)
    local l_isPortrait_0 = v24.props.isPortrait;
    return l_withLocalization_0({})(function(_)
        return v2.createElement(v12.Container, {
            titleText = "Accessory Adjustment",
            NextSelectionDown = v24.adjustmentButtonRef,
            transparentBackground = true,
            hideSiteMessageBanner = l_isPortrait_0,
            leftItem = v24.backButtonComponent,
            ref = v24.topBarRef
        });
    end);
end;
v22.render = function(v27)
    return v2.createElement(l_Focusable_0.Frame, {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        focusController = v27.focusController,
        defaultChild = v27.refinementNavBarRef
    }, {
        TopBar = v27:renderTopBar(),
        RefinementNavBar = v2.createElement(v19, {
            NextSelectionRight = v27.verticalDrawerRef,
            NextSelectionUp = v27.topBarRef,
            ref = v27.refinementNavBarRef
        }),
        VerticalDrawer = v2.createElement(v20, {
            ref = v27.verticalDrawerRef,
            NextSelectionLeft = v27.refinementNavBarRef
        }),
        GamepadFocusHandlerForPage = v2.createElement(v21, {
            focusController = v27.focusController,
            captureFocusOnMount = true
        })
    });
end;
return (l_withNavigation_0(l_RoactServices_0.connect({
    avatarExperienceAnalytics = v11
})((v3.connect(function(v28, _)
    return {
        isPortrait = v28.DeviceOrientation == l_DeviceOrientationMode_0.Portrait,
        fullView = v15(v28, v13.AccessoryAdjustment)
    };
end, function(v30)
    return {
        setFullView = function(v31, v32)
            v30(v14(v31, v13.AccessoryAdjustment, v32));
        end
    };
end)(v22))), nil));


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.UIBlox);
local v5 = require(l_CorePackages_0.Packages.t);
local l_withStyle_0 = v4.Style.withStyle;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v8 = require(l_Modules_0.AvatarExperience.Common.Constants);
local v9 = require(l_Modules_0.AvatarExperience.Common.Selectors.DEPRECATED_ItemData);
local _ = require(l_Modules_0.AvatarExperience.Common.AvatarExperienceState);
local v11 = require(l_Modules_0.AvatarExperience.Flags.FFlagAXFixItemTypeHandling);
local v12 = v2.PureComponent:extend("AccessoryName");
v12.validateProps = v5.strictInterface({
    LayoutOrder = v5.number,
    name = v5.string
});
v12.render = function(v13)
    return l_withStyle_0(function(v14)
        return v13:renderWithProviders(v14);
    end);
end;
v12.renderWithProviders = function(v15, v16)
    local l_Theme_0 = v16.Theme;
    local l_Font_0 = v16.Font;
    return v2.createElement("TextLabel", {
        AutomaticSize = Enum.AutomaticSize.Y,
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Font = l_Font_0.Header1.Font,
        LayoutOrder = v15.props.LayoutOrder,
        Size = UDim2.new(1, 0, 0, 0),
        Text = v15.props.name,
        TextSize = l_Font_0.BaseSize * l_Font_0.Header1.RelativeSize,
        TextColor3 = l_Theme_0.TextEmphasis.Color,
        TextTransparency = l_Theme_0.TextEmphasis.Transparency,
        TextWrapped = true,
        TextXAlignment = Enum.TextXAlignment.Center,
        TextYAlignment = Enum.TextYAlignment.Center
    });
end;
return (v3.connect(function(v19, _)
    local l_SelectedAccessory_0 = v19.AvatarExperience.AccessoryAdjustment.SelectedAccessory;
    if not v11 then
        local v22 = v9(v19.AvatarExperience.Common, l_SelectedAccessory_0, v8.ItemType.Asset);
        return {
            name = not not v22 and v22.name or ""
        };
    else
        local v23 = "";
        if l_SelectedAccessory_0 then
            local v24 = v19.AvatarExperience.Common.AssetInfos[l_SelectedAccessory_0];
            if not (not v24 or not v24.name) then
                v23 = v24.name;
            end;
        end;
        return {
            name = v23
        };
    end;
end, nil)(v12));


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local l_CorePackages_0 = game:GetService("CorePackages");
local v2 = require(l_CorePackages_0.Packages.Cryo);
local v3 = require(l_CorePackages_0.Packages.React);
local v4 = require(l_CorePackages_0.RoactNavigation);
local l_useStyle_0 = require(l_CorePackages_0.UIBlox).Core.Style.useStyle;
local l_withNavigationFocus_0 = v4.withNavigationFocus;
local v7 = require(l_Modules_0.AvatarExperience.Common.Components.RoactNavigation.withAppRoute);
local l_PeekView_0 = require(l_CorePackages_0.Workspace.Packages.PeekView).PeekView;
local l_PeekViewState_0 = require(l_CorePackages_0.Workspace.Packages.PeekView).PeekViewState;
local v10 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.AdjustAccessoryView_DEPRECATED);
local v11 = require(l_Modules_0.LuaApp.Components.TopBar.TopBar);
local _ = function(_)
    return v3.createElement(v11.Container, {
        titleText = "Adjustment",
        transparentBackground = true,
        leftItem = v11.BackButton
    });
end;
local v16 = l_withNavigationFocus_0((v7(function(_)
    local l_Theme_0 = l_useStyle_0().Theme;
    return v3.createElement("Frame", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1
    }, {
        TopBar = v3.createElement(v11.Container, {
            titleText = "Adjustment",
            transparentBackground = true,
            leftItem = v11.BackButton
        }),
        PeekView = v3.createElement(l_PeekView_0, {
            briefViewContentHeight = UDim.new(0, 48),
            mountAsFullView = false,
            showDraggerInClosedState = true,
            thumbstickScrollEnabled = true,
            backgroundColor3 = l_Theme_0.BackgroundDefault.Color,
            backgroundTransparency = l_Theme_0.BackgroundUIDefault.Transparency,
            peekHeaderClose = false,
            isScrollingEnabled = true,
            peekViewState = l_PeekViewState_0.SuperBrief
        }, {
            Content = v3.createElement(v10)
        })
    });
end)));
return v3.forwardRef(function(v17, v18)
    return v3.createElement(v16, v2.Dictionary.join(v17, {
        defaultChildRef = v18
    }));
end);


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.UIBlox);
local v5 = require(l_CorePackages_0.Packages.t);
local l_withStyle_0 = v4.Style.withStyle;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v8 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.AdjustmentTypeButtons);
local v9 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.AdjustmentSliders);
local v10 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.AdjustmentBottomSection);
local _ = require(l_Modules_0.LuaApp.RootState);
local v12 = v2.PureComponent:extend("AdjustAccessoryView");
v12.validateProps = v5.strictInterface({});
v12.render = function(v13)
    return l_withStyle_0(function(v14)
        return v13:renderWithProviders(v14);
    end);
end;
v12.renderWithProviders = function(_, v16)
    local l_Theme_0 = v16.Theme;
    return v2.createElement("Frame", {
        AutomaticSize = Enum.AutomaticSize.Y,
        Size = UDim2.fromScale(1, 1),
        BackgroundColor3 = l_Theme_0.BackgroundDefault.Color,
        BackgroundTransparency = l_Theme_0.BackgroundDefault.Transparency,
        BorderSizePixel = 0
    }, {
        UIPadding = v2.createElement("UIPadding", {
            PaddingTop = UDim.new(0, 0),
            PaddingBottom = UDim.new(0, 24),
            PaddingLeft = UDim.new(0, 24),
            PaddingRight = UDim.new(0, 24)
        }),
        UIListLayout = v2.createElement("UIListLayout", {
            Padding = UDim.new(0, 24),
            SortOrder = Enum.SortOrder.LayoutOrder
        }),
        AdjustmentTypeButtons = v2.createElement(v8, {
            LayoutOrder = 2
        }),
        AdjustmentSliders = v2.createElement(v9, {
            LayoutOrder = 3
        }),
        AdjustmentBottomSection = v2.createElement(v10, {
            LayoutOrder = 4
        })
    });
end;
return (v3.connect(function(_, _)
    return {};
end, function(_)
    return {};
end)(v12));


local l_CorePackages_0 = game:GetService("CorePackages");
local v1 = require(l_CorePackages_0.Roact);
local v2 = require(l_CorePackages_0.Packages.t);
local v3 = require(l_CorePackages_0.UIBlox);
local l_withStyle_0 = v3.Style.withStyle;
local l_Images_0 = v3.App.ImageSet.Images;
local l_ImageSetButton_0 = v3.Core.ImageSet.ImageSetButton;
local l_Button_0 = v3.App.Button.Button;
local l_ButtonType_0 = v3.App.Button.Enum.ButtonType;
local v9 = l_Images_0["icons/placeholder/placeholderOn"];
local v10 = v1.PureComponent:extend("AdjustmentBottomSection");
v10.validateProps = v2.strictInterface({
    LayoutOrder = v2.number
});
v10.render = function(v11)
    return l_withStyle_0(function(v12)
        return v11:renderWithProviders(v12);
    end);
end;
v10.renderWithProviders = function(v13, v14)
    local l_Theme_0 = v14.Theme;
    return v1.createElement("Frame", {
        AutomaticSize = Enum.AutomaticSize.Y,
        Size = UDim2.fromScale(1, 0),
        BackgroundColor3 = l_Theme_0.BackgroundDefault.Color,
        BackgroundTransparency = 1,
        LayoutOrder = v13.props.LayoutOrder
    }, {
        UIListLayout = v1.createElement("UIListLayout", {
            Padding = UDim.new(0, 12),
            SortOrder = Enum.SortOrder.LayoutOrder,
            FillDirection = Enum.FillDirection.Horizontal,
            HorizontalAlignment = Enum.HorizontalAlignment.Center,
            VerticalAlignment = Enum.VerticalAlignment.Center
        }),
        UIPadding = v1.createElement("UIPadding", {
            PaddingLeft = UDim.new(0, 4)
        }),
        ResetButton = v1.createElement(l_ImageSetButton_0, {
            Size = UDim2.new(0, 28, 0, 28),
            BackgroundTransparency = 1,
            Image = v9,
            ImageColor3 = l_Theme_0.DropShadow.Color,
            ImageTransparency = 0,
            LayoutOrder = 1,
            ZIndex = 2,
            [v1.Event.Activated] = function()
            end
        }),
        DoneButton = v1.createElement(l_Button_0, {
            buttonType = l_ButtonType_0.PrimarySystem,
            size = UDim2.new(1, -40, 0, 48),
            layoutOrder = 2,
            text = "Done",
            onActivated = function()
            end
        })
    });
end;
return v10;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local v5 = require(l_CorePackages_0.UIBlox);
local l_withStyle_0 = v5.Style.withStyle;
local l_SystemSlider_0 = v5.App.Slider.SystemSlider;
local l_Images_0 = v5.App.ImageSet.Images;
local l_ImageSetLabel_0 = v5.Core.ImageSet.ImageSetLabel;
local l_IconSize_0 = v5.App.Constant.IconSize;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v12 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Enum.AdjustmentSliderType);
local v13 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Actions.SetAdjustmentSliders);
local _ = require(l_Modules_0.AvatarExperience.Common.AvatarExperienceState);
local v15 = {
    [v12.PositionX] = l_Images_0["icons/menu/adjust/positionX"],
    [v12.PositionY] = l_Images_0["icons/menu/adjust/positionY"],
    [v12.PositionZ] = l_Images_0["icons/menu/adjust/positionZ"],
    [v12.RotationX] = l_Images_0["icons/menu/adjust/rotationX"],
    [v12.RotationY] = l_Images_0["icons/menu/adjust/rotationY"],
    [v12.RotationZ] = l_Images_0["icons/menu/adjust/rotationZ"],
    [v12.Scale] = l_Images_0["icons/menu/adjust/scale"]
};
local v16 = v2.PureComponent:extend("AdjustmentSlider");
v16.validateProps = v4.strictInterface({
    LayoutOrder = v4.number,
    adjustmentSliderType = v4.userdata,
    adjustmentTypeSelected = v4.userdata,
    sliderInfo = v4.optional(v4.table),
    selectedAccessory = v4.optional(v4.string),
    setAdjustmentSliders = v4.callback
});
v16.init = function(v17)
    v17.onValueChanged = function(v18)
        v17.props.setAdjustmentSliders(v17.props.adjustmentSliderType, v17.props.selectedAccessory, v18);
    end;
end;
v16.render = function(v19)
    return l_withStyle_0(function(v20)
        return v19:renderWithProviders(v20);
    end);
end;
v16.renderWithProviders = function(v21, v22)
    local l_Theme_0 = v22.Theme;
    return v2.createElement("Frame", {
        AutomaticSize = Enum.AutomaticSize.Y,
        Size = UDim2.fromScale(1, 0),
        BackgroundColor3 = l_Theme_0.BackgroundDefault.Color,
        BackgroundTransparency = 1,
        LayoutOrder = v21.props.LayoutOrder
    }, {
        UIListLayout = v2.createElement("UIListLayout", {
            Padding = UDim.new(0, 24),
            SortOrder = Enum.SortOrder.LayoutOrder,
            FillDirection = Enum.FillDirection.Horizontal,
            HorizontalAlignment = Enum.HorizontalAlignment.Left,
            VerticalAlignment = Enum.VerticalAlignment.Center
        }),
        SliderImage = v2.createElement(l_ImageSetLabel_0, {
            BackgroundTransparency = 1,
            Image = v15[v21.props.adjustmentSliderType],
            Size = UDim2.new(0, l_IconSize_0.Small, 0, l_IconSize_0.Small),
            ImageColor3 = l_Theme_0.IconEmphasis.Color,
            ImageTransparency = l_Theme_0.IconEmphasis.Transparency
        }),
        Slider = v2.createElement(l_SystemSlider_0, {
            min = -100,
            max = 100,
            stepInterval = 1,
            value = not not v21.props.sliderInfo and v21.props.sliderInfo[v21.props.adjustmentSliderType] or 0,
            onValueChanged = v21.onValueChanged,
            width = UDim.new(0.75, -24),
            layoutOrder = 2
        })
    });
end;
return (v3.connect(function(v24, _)
    local l_AdjustmentTypeSelected_0 = v24.AvatarExperience.AccessoryAdjustment.AdjustmentTypeSelected;
    local l_SelectedAccessory_0 = v24.AvatarExperience.AccessoryAdjustment.SelectedAccessory;
    return {
        adjustmentTypeSelected = l_AdjustmentTypeSelected_0,
        selectedAccessory = l_SelectedAccessory_0,
        sliderInfo = l_SelectedAccessory_0 and v24.AvatarExperience.AccessoryAdjustment.AdjustmentSliders[l_SelectedAccessory_0]
    };
end, function(v28)
    return {
        setAdjustmentSliders = function(v29, v30, v31)
            v28(v13(v29, v30, v31));
        end
    };
end)(v16));


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local l_withStyle_0 = require(l_CorePackages_0.UIBlox).Style.withStyle;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v7 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.AdjustmentSlider);
local v8 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Enum.AdjustmentSliderType);
local v9 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Enum.AdjustmentTypeEnum);
local _ = require(l_Modules_0.AvatarExperience.Common.AvatarExperienceState);
local v11 = v2.PureComponent:extend("AdjustmentSliders");
v11.validateProps = v4.strictInterface({
    LayoutOrder = v4.number,
    adjustmentTypeSelected = v4.userdata
});
v11.getSliders = function(v12)
    local v13 = {};
    if v12.props.adjustmentTypeSelected == v9.Position then
        table.insert(v13, v2.createElement(v7, {
            LayoutOrder = 1,
            adjustmentSliderType = v8.PositionX
        }));
        table.insert(v13, v2.createElement(v7, {
            LayoutOrder = 2,
            adjustmentSliderType = v8.PositionY
        }));
        table.insert(v13, v2.createElement(v7, {
            LayoutOrder = 3,
            adjustmentSliderType = v8.PositionZ
        }));
        return v13;
    elseif v12.props.adjustmentTypeSelected == v9.Rotation then
        table.insert(v13, v2.createElement(v7, {
            LayoutOrder = 1,
            adjustmentSliderType = v8.RotationX
        }));
        table.insert(v13, v2.createElement(v7, {
            LayoutOrder = 2,
            adjustmentSliderType = v8.RotationY
        }));
        table.insert(v13, v2.createElement(v7, {
            LayoutOrder = 3,
            adjustmentSliderType = v8.RotationZ
        }));
        return v13;
    else
        if v12.props.adjustmentTypeSelected == v9.Scale then
            table.insert(v13, v2.createElement(v7, {
                LayoutOrder = 1,
                adjustmentSliderType = v8.Scale
            }));
        end;
        return v13;
    end;
end;
v11.render = function(v14)
    return l_withStyle_0(function(v15)
        return v14:renderWithProviders(v15);
    end);
end;
v11.renderWithProviders = function(v16, v17)
    local l_Theme_0 = v17.Theme;
    local v19 = v16:getSliders();
    v19.UIListLayout = v2.createElement("UIListLayout", {
        Padding = UDim.new(0, 24),
        SortOrder = Enum.SortOrder.LayoutOrder,
        FillDirection = Enum.FillDirection.Vertical,
        HorizontalAlignment = Enum.HorizontalAlignment.Center,
        VerticalAlignment = Enum.VerticalAlignment.Top
    });
    return v2.createElement("Frame", {
        AutomaticSize = Enum.AutomaticSize.Y,
        Size = UDim2.fromScale(1, 0),
        BackgroundColor3 = l_Theme_0.BackgroundDefault.Color,
        BackgroundTransparency = 1,
        LayoutOrder = v16.props.LayoutOrder
    }, v19);
end;
return (v3.connect(function(v20, _)
    return {
        adjustmentTypeSelected = v20.AvatarExperience.AccessoryAdjustment.AdjustmentTypeSelected
    };
end, nil)(v11));


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local v5 = require(l_CorePackages_0.UIBlox);
local l_Images_0 = v5.App.ImageSet.Images;
local l_ImageSetButton_0 = v5.Core.ImageSet.ImageSetButton;
local l_withStyle_0 = v5.Style.withStyle;
local l_IconSize_0 = v5.App.Constant.IconSize;
local v10 = require(l_CoreGui_0.RobloxGui.Modules.AvatarExperience.AccessoryAdjustment.Actions.SetAdjustmentType);
local v11 = l_Images_0["icons/placeholder/placeholderOn"];
local v12 = v2.PureComponent:extend("AdjustmentTypeButton");
v12.validateProps = v4.strictInterface({
    LayoutOrder = v4.number,
    adjustmentType = v4.userdata,
    isSelected = v4.optional(v4.boolean),
    setAdjustmentType = v4.callback
});
v12.defaultProps = {
    isSelected = false
};
v12.init = function(v13)
    v13.setAdjustmentType = function()
        v13.props.setAdjustmentType(v13.props.adjustmentType);
    end;
end;
v12.render = function(v14)
    return l_withStyle_0(function(v15)
        return v14:renderWithProviders(v15);
    end);
end;
v12.renderWithProviders = function(v16, v17)
    local l_Theme_0 = v17.Theme;
    local l_Color_0 = l_Theme_0.BackgroundUIDefault.Color;
    local l_Transparency_0 = l_Theme_0.BackgroundUIDefault.Transparency;
    if v16.props.isSelected then
        l_Color_0 = l_Theme_0.UIDefault.Color;
        l_Transparency_0 = l_Theme_0.UIDefault.Transparency;
    end;
    return v2.createElement("ImageButton", {
        Size = UDim2.fromScale(0.3333333333333333, 1),
        BackgroundColor3 = l_Color_0,
        BackgroundTransparency = l_Transparency_0,
        LayoutOrder = v16.props.LayoutOrder,
        [v2.Event.Activated] = v16.setAdjustmentType
    }, {
        UICorner = v2.createElement("UICorner", {
            CornerRadius = UDim.new(0, 8)
        }),
        Image = v2.createElement(l_ImageSetButton_0, {
            AnchorPoint = Vector2.new(0.5, 0.5),
            Position = UDim2.new(0.5, 0, 0.5, 0),
            Size = UDim2.new(0, l_IconSize_0.Small, 0, l_IconSize_0.Small),
            BackgroundTransparency = 1,
            Image = v11,
            ImageColor3 = l_Theme_0.IconDefault.Color,
            ImageTransparency = l_Theme_0.IconDefault.Transparency
        })
    });
end;
return (v3.connect(nil, function(v21)
    return {
        setAdjustmentType = function(v22)
            v21(v10(v22));
        end
    };
end)(v12));


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local l_withStyle_0 = require(l_CorePackages_0.UIBlox).Style.withStyle;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v7 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.AdjustmentTypeButton);
local v8 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Enum.AdjustmentTypeEnum);
local _ = require(l_Modules_0.AvatarExperience.Common.AvatarExperienceState);
local v10 = v2.PureComponent:extend("AdjustmentTypeButtons");
v10.validateProps = v4.strictInterface({
    LayoutOrder = v4.number,
    adjustmentTypeSelected = v4.userdata
});
v10.render = function(v11)
    return l_withStyle_0(function(v12)
        return v11:renderWithProviders(v12);
    end);
end;
v10.renderWithProviders = function(v13, v14)
    local l_Theme_0 = v14.Theme;
    return v2.createElement("Frame", {
        Size = UDim2.new(1, 0, 0, 36),
        BackgroundColor3 = l_Theme_0.BackgroundUIDefault.Color,
        BackgroundTransparency = l_Theme_0.BackgroundUIDefault.Transparency,
        LayoutOrder = v13.props.LayoutOrder
    }, {
        UICorner = v2.createElement("UICorner", {
            CornerRadius = UDim.new(0, 8)
        }),
        UIPadding = v2.createElement("UIPadding", {
            PaddingTop = UDim.new(0, 4),
            PaddingBottom = UDim.new(0, 4),
            PaddingLeft = UDim.new(0, 4),
            PaddingRight = UDim.new(0, 4)
        }),
        UIListLayout = v2.createElement("UIListLayout", {
            Padding = UDim.new(0, 0),
            SortOrder = Enum.SortOrder.LayoutOrder,
            FillDirection = Enum.FillDirection.Horizontal,
            HorizontalAlignment = Enum.HorizontalAlignment.Center,
            VerticalAlignment = Enum.VerticalAlignment.Center
        }),
        MoveButton = v2.createElement(v7, {
            LayoutOrder = 1,
            isSelected = v13.props.adjustmentTypeSelected == v8.Position,
            adjustmentType = v8.Position
        }),
        Divider1 = v2.createElement("Frame", {
            Size = UDim2.new(0, 1, 1, 0),
            BackgroundColor3 = l_Theme_0.Divider.Color,
            BackgroundTransparency = l_Theme_0.Divider.Transparency,
            LayoutOrder = 2,
            Visible = v13.props.adjustmentTypeSelected == v8.Scale
        }),
        RotateButton = v2.createElement(v7, {
            LayoutOrder = 3,
            isSelected = v13.props.adjustmentTypeSelected == v8.Rotation,
            adjustmentType = v8.Rotation
        }),
        Divider2 = v2.createElement("Frame", {
            Size = UDim2.new(0, 1, 1, 0),
            BackgroundColor3 = l_Theme_0.Divider.Color,
            BackgroundTransparency = l_Theme_0.Divider.Transparency,
            LayoutOrder = 4,
            Visible = v13.props.adjustmentTypeSelected == v8.Position
        }),
        ScaleButton = v2.createElement(v7, {
            LayoutOrder = 5,
            isSelected = v13.props.adjustmentTypeSelected == v8.Scale,
            adjustmentType = v8.Scale
        })
    });
end;
return (v3.connect(function(v16, _)
    return {
        adjustmentTypeSelected = v16.AvatarExperience.AccessoryAdjustment.AdjustmentTypeSelected
    };
end, nil)(v10));


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local l_RunService_0 = game:GetService("RunService");
local l_UserInputService_0 = game:GetService("UserInputService");
local v4 = require(l_CorePackages_0.Roact);
local v5 = require(l_CorePackages_0.RoactRodux);
local v6 = require(l_CorePackages_0.Packages.t);
local v7 = require(l_CorePackages_0.Otter);
local v8 = require(l_CorePackages_0.UIBlox);
local l_ExternalEventConnection_0 = v8.Utility.ExternalEventConnection;
local l_GridMetrics_0 = v8.App.Grid.GridMetrics;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v12 = require(l_Modules_0.AvatarExperience.AvatarEditor.Constants);
local v13 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.AccessoryAdjustmentUtils);
local v14 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Components.ItemSelectorTile);
local _ = require(l_Modules_0.AvatarExperience.Common.AvatarExperienceState);
local v16 = l_GridMetrics_0.makeCustomMetricsGetter(v12.ItemsGridMetrics);
local v17 = {
    dampingRatio = 2,
    frequency = 5
};
local v18 = v4.PureComponent:extend("ItemSelectorCarousel");
v18.validateProps = v6.strictInterface({
    itemSelectorCarouselRef = v6.table,
    equippedAccessories = v6.table
});
v18.init = function(v19)
    v19.scrollingFrameRef = v4.createRef();
    v19.ref = v4.createRef();
    v19.refCache = {};
    v19:setState({
        containerWidth = 0
    });
    v19.setContainerWidth = function(v20)
        if not (not v20 or not v20:IsDescendantOf(game)) then
            v19:setState({
                containerWidth = v20.AbsoluteSize.X
            });
        end;
    end;
    v19.inputBeganCallback = function(v21)
        if v19.isMounted then
            if v21.UserInputType ~= Enum.UserInputType.MouseMovement and v21.UserInputType ~= Enum.UserInputType.Touch then
                return ;
            else
                v19:disconnectInertialMoveConn();
                v19.isTouched = true;
                return ;
            end;
        else
            return ;
        end;
    end;
    v19.inputEndedCallback = function(_)
        if v19.isMounted then
            if v19.isTouched then
                v19.isTouched = false;
                v19:handleInertialMove();
            end;
            return ;
        else
            return ;
        end;
    end;
end;
v18.didUpdate = function(v23, _, v25)
    if v23.state.containerWidth > 0 and v25.containerWidth == 0 then
        v23:initCanvasPosition();
    end;
end;
v18.createOrResetMotor = function(v26, v27)
    if v26.motor then
        v26.motor:destroy();
    end;
    local v28 = v7.createSingleMotor(v27);
    v26.motor = v28;
    v26.motor:onStep(function(v29)
        if v26.motor ~= v28 then
            v28:destroy();
            return ;
        elseif not v26.isTouched then
            v26.scrollingFrameRef.current.CanvasPosition = Vector2.new(v29, 0);
            return ;
        else
            v26.motor:destroy();
            v26.motor = nil;
            return ;
        end;
    end);
    v26.motor:start();
end;
v18.initCanvasPosition = function(v30)
    local v31 = v30.scrollingFrameRef:getValue();
    if not v30.isTouched and v31 then
        v30:createOrResetMotor(v31.CanvasPosition.X);
        v30:setScrollPosition(v30.props.equippedAccessories[1], true);
        return ;
    else
        return ;
    end;
end;
v18.handleInertialMove = function(v32)
    local v33 = nil;
    local v34 = v32.scrollingFrameRef:getValue();
    if not v32.isTouched and v34 then
        v33 = -v34:GetSampledInertialVelocity().X;
        v34:ClearInertialScrolling();
        local v35 = v32:getClosestTileToCenter();
        if math.abs(v33) < 10 then
            v32:createOrResetMotor(v34.CanvasPosition.X);
            v32:setScrollPosition(v35, false);
            return ;
        else
            v32:disconnectInertialMoveConn();
            v32.handleInertialMoveConn = l_RunService_0.RenderStepped:Connect(function(v36)
                local v37 = v32.scrollingFrameRef:getValue();
                if v37 then
                    local v38, v39 = v32:getClosestTileToCenter();
                    if math.abs(v33) < 10 then
                        v32:disconnectInertialMoveConn();
                        v32:createOrResetMotor(v37.CanvasPosition.X);
                        v32:setScrollPosition(v38, false);
                        return ;
                    else
                        v37.CanvasPosition = v37.CanvasPosition + Vector2.new(v33 * v36, 0);
                        v33 = v33 * (0.9 / math.max(1, 10 - v39));
                        return ;
                    end;
                else
                    v32:disconnectInertialMoveConn();
                    return ;
                end;
            end);
            return ;
        end;
    else
        return ;
    end;
end;
v18.getClosestTileToCenter = function(v40)
    local v41 = v40.scrollingFrameRef:getValue();
    if v41 then
        local v42 = v41.AbsolutePosition.X + v41.AbsoluteSize.X / 2;
        local l_huge_0 = math.huge;
        local v44 = nil;
        for v45, v46 in v40.refCache, nil, nil do
            local v47 = v46:getValue();
            if v47 then
                local v48 = math.abs(v42 - (v47.AbsolutePosition.X + v47.AbsoluteSize.X / 2));
                if v48 < l_huge_0 then
                    l_huge_0 = v48;
                    v44 = v45;
                end;
            end;
        end;
        return v44, l_huge_0;
    else
        return ;
    end;
end;
v18.setScrollPosition = function(v49, v50, v51)
    local l_current_0 = v49.scrollingFrameRef.current;
    if (l_current_0 and l_current_0.AbsoluteSize.X ~= 0) and v50 then
        local v53 = v49.refCache[v50]:getValue();
        if v53 then
            if v49.motor then
                local v54 = (l_current_0.CanvasPosition.X + (v53.AbsolutePosition.X + v53.AbsoluteSize.X / 2)) - (l_current_0.AbsolutePosition.X + l_current_0.AbsoluteSize.X / 2);
                if not v51 then
                    v49.motor:setGoal(v7.spring(v54, v17));
                    return ;
                else
                    v49.motor:setGoal(v7.instant(v54));
                    return ;
                end;
            else
                return ;
            end;
        else
            return ;
        end;
    else
        return ;
    end;
end;
v18.didMount = function(v55)
    v55.isMounted = true;
    v55.setContainerWidth(v55.ref:getValue());
    v55:createOrResetMotor(0);
end;
v18.gatherChildren = function(v56)
    local l_itemWidth_0 = v16(v56.state.containerWidth or 0, 10).itemWidth;
    local v58 = {};
    for v59, v60 in v56.props.equippedAccessories, nil, nil do
        if not v56.refCache[v60] then
            v56.refCache[v60] = v4.createRef();
        end;
        table.insert(v58, v4.createElement(v14, {
            assetId = v60,
            tileSize = l_itemWidth_0,
            tileRef = v56.refCache[v60],
            LayoutOrder = v59 + 1
        }));
    end;
    local v61 = nil;
    v61 = if v56.state.containerWidth > 0 then v56.state.containerWidth / 2 else l_itemWidth_0;
    table.insert(v58, 1, v4.createElement("Frame", {
        Size = UDim2.new(0, v61, 0, v61),
        BackgroundTransparency = 1,
        LayoutOrder = 1
    }));
    table.insert(v58, v4.createElement("Frame", {
        Size = UDim2.new(0, v61, 0, v61),
        BackgroundTransparency = 1,
        LayoutOrder = #v58 + 1
    }));
    table.insert(v58, v4.createElement("UIListLayout", {
        FillDirection = Enum.FillDirection.Horizontal,
        SortOrder = Enum.SortOrder.LayoutOrder,
        HorizontalAlignment = Enum.HorizontalAlignment.Left,
        VerticalAlignment = Enum.VerticalAlignment.Bottom,
        Padding = UDim.new(0, 12)
    }));
    return v58;
end;
v18.render = function(v62)
    return v4.createElement("Frame", {
        Size = UDim2.fromScale(1, 1),
        BackgroundTransparency = 1,
        [v4.Ref] = v62.ref,
        [v4.Change.AbsoluteSize] = v62.setContainerWidth,
        [v4.Event.AncestryChanged] = v62.setContainerWidth
    }, {
        UIPadding = v4.createElement("UIPadding", {
            PaddingLeft = UDim.new(0, v12.ItemsGridSidePadding / 2),
            PaddingRight = UDim.new(0, v12.ItemsGridSidePadding / 2),
            PaddingBottom = UDim.new(0, v12.ItemsGridBottomPadding)
        }),
        InputBegan = v4.createElement(l_ExternalEventConnection_0, {
            event = l_UserInputService_0.InputBegan,
            callback = v62.inputBeganCallback
        }),
        InputEnded = v4.createElement(l_ExternalEventConnection_0, {
            event = l_UserInputService_0.InputEnded,
            callback = v62.inputEndedCallback
        }),
        ScrollingFrame = v4.createElement("ScrollingFrame", {
            AutomaticSize = Enum.AutomaticSize.Y,
            AutomaticCanvasSize = Enum.AutomaticSize.XY,
            ScrollingDirection = Enum.ScrollingDirection.X,
            ScrollBarThickness = 0,
            ElasticBehavior = Enum.ElasticBehavior.Always,
            Size = UDim2.new(1, 0, 1, 0),
            BackgroundTransparency = 1,
            [v4.Ref] = v62.scrollingFrameRef
        }, (v62:gatherChildren()))
    });
end;
v18.willUnmount = function(v63)
    v63.isMounted = false;
    v63:disconnectInertialMoveConn();
    if v63.motor then
        v63.motor:destroy();
        v63.motor = nil;
    end;
end;
v18.disconnectInertialMoveConn = function(v64)
    if v64.handleInertialMoveConn then
        v64.handleInertialMoveConn:Disconnect();
        v64.handleInertialMoveConn = nil;
    end;
end;
return (v5.connect(function(v65, _)
    return {
        equippedAccessories = v13.getEquippedAccessories(v65)
    };
end, nil)(v18));


local l_CorePackages_0 = game:GetService("CorePackages");
local l_CoreGui_0 = game:GetService("CoreGui");
local v2 = require(l_CorePackages_0.Roact);
local v3 = require(l_CorePackages_0.RoactRodux);
local v4 = require(l_CorePackages_0.Packages.t);
local l_withNavigation_0 = require(l_CorePackages_0.RoactNavigation).withNavigation;
local l_ItemTile_0 = require(l_CorePackages_0.UIBlox).Tile.ItemTile;
local l_Modules_0 = l_CoreGui_0.RobloxGui.Modules;
local v8 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.Actions.SetSelectedAccessory);
local v9 = require(l_Modules_0.AvatarExperience.Common.Components.RoactNavigation.AvatarScreen);
local v10 = require(l_CorePackages_0.Workspace.Packages.UserLib);
local l_getRbxthumbWithTypeSizeAndOptions_0 = v10.Utils.getRbxthumbWithTypeSizeAndOptions;
local l_Constants_0 = v10.Utils.Constants;
local v13 = v2.PureComponent:extend("ItemSelectorTile");
v13.validateProps = v4.strictInterface({
    assetId = v4.string,
    tileSize = v4.number,
    tileRef = v4.table,
    LayoutOrder = v4.number,
    setSelectedAccessory = v4.callback,
    navigation = v4.table
});
v13.init = function(v14)
    v14.selectItem = function()
        v14.props.setSelectedAccessory(v14.props.assetId);
        v14.props.navigation.navigate(v9.AccessoryAdjustment);
    end;
end;
v13.render = function(v15)
    local l_tileSize_0 = v15.props.tileSize;
    local v17 = nil;
    if v15.props.assetId then
        v17 = l_getRbxthumbWithTypeSizeAndOptions_0(v15.props.assetId, l_Constants_0.RbxthumbTypes.Asset, 150);
    end;
    return v2.createElement("Frame", {
        Size = UDim2.fromOffset(l_tileSize_0, l_tileSize_0),
        BackgroundTransparency = 1,
        LayoutOrder = v15.props.LayoutOrder,
        [v2.Ref] = v15.props.tileRef
    }, {
        ItemTile = v2.createElement(l_ItemTile_0, {
            titleTextLineCount = 0,
            thumbnail = v17,
            onActivated = v15.selectItem
        })
    });
end;
return (v3.connect(nil, function(v18)
    return {
        setSelectedAccessory = function(v19)
            v18(v8(v19));
        end
    };
end)((l_withNavigation_0(v13, nil))));


local l_Modules_0 = game:GetService("CoreGui").RobloxGui.Modules;
local l_CorePackages_0 = game:GetService("CorePackages");
local v2 = require(l_CorePackages_0.Packages.Cryo);
local v3 = require(l_CorePackages_0.Packages.React);
local v4 = require(l_CorePackages_0.Packages.Roact);
local v5 = require(l_CorePackages_0.UIBlox);
local v6 = require(l_CorePackages_0.Packages.RoactGamepad);
local l_Focusable_0 = v6.Focusable;
local l_useStyle_0 = v5.Core.Style.useStyle;
local l_CursorKind_0 = v5.App.SelectionImage.CursorKind;
local l_useSelectionCursor_0 = v5.App.SelectionImage.useSelectionCursor;
local l_useSelector_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).Hooks.RoactRodux.useSelector;
local l_useProperty_0 = require(l_CorePackages_0.Workspace.Packages.RoactUtils).Hooks.useProperty;
local l_DeviceOrientationMode_0 = require(l_CorePackages_0.Workspace.Packages.RobloxAppEnums).DeviceOrientationMode;
local l_withNavigationFocus_0 = require(l_CorePackages_0.RoactNavigation).withNavigationFocus;
local v15 = require(l_Modules_0.AvatarExperience.Common.Components.RoactNavigation.withAppRoute);
local v16 = require(l_Modules_0.AvatarExperience.AccessoryAdjustment.AccessoryAdjustmentUtils);
local l_LoadableImage_0 = v5.App.Loading.LoadableImage;
local v18 = require(l_Modules_0.AvatarExperience.Common.Components.RoactNavigation.AvatarScreen);
local v19 = require(l_CorePackages_0.Workspace.Packages.UserLib);
local l_getRbxthumbWithTypeSizeAndOptions_0 = v19.Utils.getRbxthumbWithTypeSizeAndOptions;
local l_Constants_0 = v19.Utils.Constants;
local v22 = UDim.new(0, 6);
local function v24(v23)
    return v23.DeviceOrientation == l_DeviceOrientationMode_0.Portrait;
end;
local function v26(v25)
    return v16.getEquippedAccessories(v25);
end;
local function v28(v27)
    return v27.TopBar.topBarHeight;
end;
local function v31(v29)
    local l_GlobalGuiInset_0 = v29.GlobalGuiInset;
    return ((((v29.ScreenSize.Y - v29.TopBar.topBarHeight) - l_GlobalGuiInset_0.bottom) - l_GlobalGuiInset_0.top) - 32) - 48;
end;
local function v40(v32, v33, v34)
    local v35 = l_useSelector_0(v26);
    local v36 = {};
    local l_Theme_0 = l_useStyle_0().Theme;
    v36.UIListLayout = v3.createElement("UIListLayout", {
        SortOrder = Enum.SortOrder.LayoutOrder,
        VerticalAlignment = Enum.VerticalAlignment.Top,
        HorizontalAlignment = Enum.HorizontalAlignment.Center,
        FillDirection = Enum.FillDirection.Vertical,
        Padding = UDim.new(0, 8),
        ref = v32
    });
    v36.UIPadding = v3.createElement("UIPadding", {
        PaddingTop = UDim.new(0, 16),
        PaddingBottom = UDim.new(0, 16),
        PaddingLeft = UDim.new(0, 8),
        PaddingRight = UDim.new(0, 8)
    });
    for v38, v39 in v35, nil, nil do
        v36[v39] = v4.createElement(l_Focusable_0.Frame, {
            Size = UDim2.fromOffset(50, 50),
            BackgroundTransparency = 1,
            SizeConstraint = Enum.SizeConstraint.RelativeXX,
            LayoutOrder = v38,
            ref = v33[v38],
            [v4.Event.Activated] = function()
                v34.navigation.navigate(v18.AdjustAccessoryView);
            end,
            inputBindings = {
                SelectSlot = v6.Input.onBegin(Enum.KeyCode.ButtonA, function()
                    v34.navigation.navigate(v18.AdjustAccessoryView);
                end, {
                    key = ""
                })
            },
            NextSelectionDown = v38 < #v35 and v33[v38 + 1] or nil,
            NextSelectionUp = v38 > 1 and v33[v38 - 1] or nil,
            SelectionImageObject = l_useSelectionCursor_0(l_CursorKind_0.RoundedRectNoInset)
        }, {
            BackgroundImage = v4.createElement("Frame", {
                BackgroundTransparency = l_Theme_0.BackgroundUIDefault.Transparency,
                BackgroundColor3 = l_Theme_0.BackgroundUIDefault.Color,
                BorderSizePixel = 0,
                AnchorPoint = Vector2.new(0.5, 0.5),
                Position = UDim2.fromScale(0.5, 0.5),
                Size = UDim2.fromScale(1, 1),
                ZIndex = 0
            }, {
                Image = v4.createElement(l_LoadableImage_0, {
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    BackgroundTransparency = 1,
                    Image = l_getRbxthumbWithTypeSizeAndOptions_0(v39, l_Constants_0.RbxthumbTypes.Asset, 150),
                    Position = UDim2.new(0.5, 0, 0.5, 0),
                    Size = UDim2.fromScale(1, 1),
                    ZIndex = 0,
                    cornerRadius = v22,
                    showFailedStateWhenLoadingFailed = true,
                    useShimmerAnimationWhileLoading = true
                }),
                UICorner = v4.createElement("UICorner", {
                    CornerRadius = v22
                })
            })
        });
    end;
    return v36;
end;
local v49 = l_withNavigationFocus_0((v15(function(v41)
    local l_Theme_1 = l_useStyle_0().Theme;
    local l_forwardRef_0 = v41.forwardRef;
    local v44 = v6.useRefCache();
    local v45 = l_useSelector_0(v28);
    local v46 = v3.useRef(nil);
    local v47 = l_useProperty_0(v46, "AbsoluteContentSize") or Vector2.new(0, 0);
    local function _()
        return (math.min(l_useSelector_0(v31), v47.Y + 32));
    end;
    return v3.createElement(l_Focusable_0.Frame, {
        AnchorPoint = Vector2.new(1, 0),
        Size = UDim2.new(0, 66, 0, (math.min(l_useSelector_0(v31), v47.Y + 32))),
        Position = UDim2.new(1, -(not l_useSelector_0(v24) and 88 or 12), 0, v45 + 4),
        BackgroundColor3 = l_Theme_1.BackgroundMuted.Color,
        BackgroundTransparency = l_Theme_1.BackgroundMuted.Transparency,
        ClipsDescendants = true,
        defaultChild = v44[1],
        ref = l_forwardRef_0,
        NextSelectionLeft = v41.NextSelectionLeft,
        restorePreviousChildFocus = true
    }, {
        UICorner = v3.createElement("UICorner", {
            CornerRadius = UDim.new(0, 8)
        }),
        ScrollingFrame = v3.createElement("ScrollingFrame", {
            AutomaticCanvasSize = Enum.AutomaticSize.Y,
            BackgroundTransparency = 1,
            CanvasSize = UDim2.new(1, 0, 0, 0),
            ScrollBarThickness = 0,
            ScrollingDirection = Enum.ScrollingDirection.Y,
            Size = UDim2.fromScale(1, 1)
        }, (v40(v46, v44, v41)))
    });
end)));
return v4.forwardRef(function(v50, v51)
    return v4.createElement(v49, v2.Dictionary.join(v50, {
        forwardRef = v51
    }));
end);


local l_CoreGui_0 = game:GetService("CoreGui");
local v1 = require(game:GetService("CorePackages").Cryo);
local v2 = require(l_CoreGui_0.RobloxGui.Modules.AvatarExperience.Common.Constants);
return {
    AdjustmentLimits = {
        [v2.AssetTypeIdStrings.Hat] = {
            Position = {
                AttachmentPoint = {
                    xMin = 1.5,
                    xMax = 1.5,
                    yMin = 2,
                    yMax = 2,
                    zMin = 1.5,
                    zMax = 1.5
                },
                DefaultPosition = v1.None
            },
            Rotation = v1.None,
            Scale = {
                min = 0.5,
                max = 1.5
            }
        },
        [v2.AssetTypeIdStrings.FaceAccessory] = {
            Position = {
                AttachmentPoint = {
                    xMin = 1.5,
                    xMax = 1.5,
                    yMin = 1,
                    yMax = 1,
                    zMin = 1,
                    zMax = 1
                },
                DefaultPosition = v1.None
            },
            Rotation = v1.None,
            Scale = {
                min = 0.5,
                max = 1.5
            }
        },
        [v2.AssetTypeIdStrings.BackAccessory] = {
            Position = {
                AttachmentPoint = {
                    xMin = 5,
                    xMax = 5,
                    yMin = 3.5,
                    yMax = 3.5,
                    zMin = 3,
                    zMax = 1.5
                },
                DefaultPosition = {
                    xMin = 5,
                    xMax = 5,
                    yMin = 3.5,
                    yMax = 3.5,
                    zMin = 3,
                    zMax = 0.5
                }
            },
            Rotation = {
                min = -30,
                max = 30
            },
            Scale = {
                min = 0.8,
                max = 1.2
            }
        },
        [v2.AssetTypeIdStrings.ShoulderAccessory] = {
            Position = {
                AttachmentPoint = {
                    xMin = 1.5,
                    xMax = 1.5,
                    yMin = 1.5,
                    yMax = 1.5,
                    zMin = 1.5,
                    zMax = 1.5
                },
                DefaultPosition = v1.None
            },
            Rotation = {
                min = -90,
                max = 90
            },
            Scale = {
                min = 0.5,
                max = 1.5
            }
        },
        [v2.AssetTypeIdStrings.NeckAccessory] = {
            Position = {
                AttachmentPoint = {
                    xMin = 1.5,
                    xMax = 1.5,
                    yMin = 1.5,
                    yMax = 1.5,
                    zMin = 1,
                    zMax = 1
                },
                DefaultPosition = v1.None
            },
            Rotation = v1.None,
            Scale = {
                min = 0.5,
                max = 1.5
            }
        },
        [v2.AssetTypeIdStrings.WaistAccessory] = {
            Position = {
                AttachmentPoint = {
                    xMin = 2,
                    xMax = 2,
                    yMin = 2,
                    yMax = 1.5,
                    zMin = 3.5,
                    zMax = 3.5
                },
                DefaultPosition = {
                    xMin = 0.5,
                    xMax = 0.5,
                    yMin = 0.25,
                    yMax = 0.25,
                    zMin = 1,
                    zMax = 1
                }
            },
            Rotation = {
                min = -60,
                max = 60
            },
            Scale = {
                min = 0.8,
                max = 1.2
            }
        },
        [v2.AssetTypeIdStrings.FrontAccessory] = {
            Position = {
                AttachmentPoint = {
                    xMin = 1.5,
                    xMax = 1.5,
                    yMin = 1.5,
                    yMax = 1.5,
                    zMin = 1.5,
                    zMax = 1.5
                },
                DefaultPosition = {
                    xMin = 0.5,
                    xMax = 0.5,
                    yMin = 0.5,
                    yMax = 0.5,
                    zMin = 0.5,
                    zMax = 0.5
                }
            },
            Rotation = {
                min = -60,
                max = 60
            },
            Scale = {
                min = 0.8,
                max = 1.2
            }
        }
    }
};


return require(game:GetService("CorePackages").enumerate)(script.Name, {
    "PositionX",
    "PositionY",
    "PositionZ",
    "RotationX",
    "RotationY",
    "RotationZ",
    "Scale"
});


return require(game:GetService("CorePackages").enumerate)(script.Name, {
    "Position",
    "Rotation",
    "Scale"
});


return {
    mock = function()
        return {};
    end,
    fromDefaultInfo = function(v0)
        return {
            defaultInfo = {
                attachment = {
                    cframe = v0.attachmentCFrame
                },
                accessory = {
                    cframe = v0.accessoryCFrame,
                    scale = v0.accessoryScale
                }
            }
        };
    end,
    fromUserInfo = function(v1)
        return {
            userAdjustedInfo = {
                cframe = v1.adjustedCFrame,
                scale = v1.adjustedScale
            }
        };
    end
};