using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using EnhancedPrefabLoader.API.Assets;
using EnhancedPrefabLoader.API.Behaviors;
using EnhancedPrefabLoader.API.Components;
using EnhancedPrefabLoader.API.Events;
using EnhancedPrefabLoader.API.InternalBridges;
using EnhancedPrefabLoader.API.Models;
using EnhancedPrefabLoader.API.Registry;
using EnhancedPrefabLoader.API.Services;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: ComVisible(false)]
[assembly: Guid("d64dc15b-8078-4750-8278-87e0065dc75e")]
[assembly: InternalsVisibleTo("EnhancedPrefabLoader")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("EnhancedPrefabLoader.API")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("6.1.0.0")]
[assembly: AssemblyInformationalVersion("6.1.0+bdc38f0600a0f9317ca7b4a8bbe5c591a46e195f")]
[assembly: AssemblyProduct("Enhanced Prefab Loader API")]
[assembly: AssemblyTitle("EnhancedPrefabLoader.API")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("6.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EnhancedPrefabLoader.API
{
	public static class Epl
	{
		private static IEplApi? instance;

		public static IEplApi Api => instance ?? throw new InvalidOperationException("EPL is not loaded");

		public static bool IsAvailable => instance != null;

		internal static void RegisterApi(IEplApi api)
		{
			instance = api;
		}
	}
	[BepInPlugin("EnhancedPrefabLoader.API", "Enhanced Prefab Loader API", "6.1.0")]
	public class EplApiPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "EnhancedPrefabLoader.API";

		public const string PluginName = "Enhanced Prefab Loader API";

		public const string PluginVersion = "6.1.0";
	}
	public interface IEplApi
	{
		bool IsBundleLoadingComplete { get; }

		IEplAssets Assets { get; }

		IEplServices Services { get; }

		IEplEvents Events { get; }

		IBundleRegistry BundleRegistry { get; }
	}
}
namespace EnhancedPrefabLoader.API.UI
{
	public interface ICustomShopScreen
	{
	}
}
namespace EnhancedPrefabLoader.API.Services
{
	public interface IBundleMaintenanceService
	{
		bool ResetPrices(string bundleId);

		bool IsUninstalled(string bundleId);
	}
	public interface ICardExpansionService
	{
		void SetCardPriceGenerator(ECardExpansionType expansionType, ICardPriceGenerator generator);

		void SetCardExpGenerator(ECardExpansionType expansionType, ICardExpGenerator generator);

		void SetFoilChance(ECardExpansionType expansionType, float foilChance);

		float GenerateCardMarketPrice(ECardExpansionType cardExpansionType, EMonsterType monsterType, bool isFoil);

		float GenerateCardMarketPrice(CardData cardData);

		float GenerateCardExp(CardData cardData);
	}
	public interface ICardUIService
	{
		void ApplyEplCardUI(CardUI cardUI, CardData cardData);

		void RestoreOriginalCardUI(CardUI cardUI, CardData cardData);
	}
	public interface IDecoService
	{
		void SetLevelRequirement(EDecoObject decoObject, int level);

		void SetPrice(EDecoObject decoObject, float price);
	}
	public interface IEplServices
	{
		IItemService ItemService { get; }

		ICardExpansionService CardExpansionService { get; }

		ICardUIService CardUIService { get; }

		IMenuService MenuService { get; }

		IFurnitureService FurnitureService { get; }

		IDecoService DecoService { get; }

		IBundleMaintenanceService BundleMaintenanceService { get; }
	}
	public interface IFurnitureService
	{
		void SetLevelRequirement(EObjectType objectType, int level);

		void SetPrice(EObjectType objectType, float price);
	}
	public interface IItemService
	{
		void SetPackGenerator(EItemType pack, IPackGenerator generator);

		List<CardData> GeneratePackContent(EItemType pack);

		void SetItemPriceGenerator(string bundleId, IItemPriceGenerator generator);

		float GenerateItemCost(EItemType itemType);

		float GenerateItemMarketPrice(EItemType itemType, float costPrice, float minMarkup, float maxMarkup);

		void SetNormalGenerationWeight(EItemType pack, ERarity rarity, float weight);

		void SetGodGenerationWeight(EItemType pack, ERarity rarity, float weight);

		void SetSlotWeight(EItemType pack, PackSlot slot, ERarity rarity, float weight);

		void SetLicensePrice(EItemType itemType, bool isBigBox, float price);

		void SetLicenseLevel(EItemType itemType, bool isBigBox, int level);

		void SetAutoBoxPrice(EItemType itemType, EItemType followItemType);

		void SetMarketPricePercent(EItemType itemType, float min, float max);

		void SetFollowItemPrice(EItemType itemType, EItemType sourceItemType);

		void SetCanHaveGodPacks(EItemType pack, bool enabled);

		void SetGodPackPercentage(EItemType pack, float percentage);

		void SetGodPack(EItemType pack, bool enabled, float percentage);
	}
	public interface IMenuService
	{
		void AddGenericExpansionButton(string label, Action onClick);

		void AddBinderExpansionButton(string label, Action onClick);
	}
}
namespace EnhancedPrefabLoader.API.Registry
{
	public interface IBundleRegistry
	{
		IReadOnlyDictionary<string, BundleInfo> BundleInfo { get; }

		string? GetBundleIdFor<TEnum>(TEnum enumValue) where TEnum : Enum;

		string? GetBundleIdFor(DecoFlags category, string assetName);

		bool IsEplAsset<TEnum>(TEnum enumValue) where TEnum : Enum;

		bool IsEplAsset(string category, string assetName);

		bool HasRegisteredRestockData(EItemType itemType);

		IReadOnlyCollection<TEnum> GetEnumValuesForBundle<TEnum>(string bundleId) where TEnum : Enum;

		IReadOnlyCollection<string> GetNamedAssetsForBundle(string bundleId, DecoFlags category);
	}
}
namespace EnhancedPrefabLoader.API.Models
{
	public class BundleInfo
	{
		internal readonly List<string> ceilingTextures = new List<string>();

		internal readonly List<string> floorTextures = new List<string>();

		internal readonly List<string> wallTextures = new List<string>();

		internal readonly List<ECardExpansionType> expansionTypes = new List<ECardExpansionType>();

		internal readonly List<EObjectType> furnitureTypes = new List<EObjectType>();

		internal readonly List<EDecoObject> decoObjects = new List<EDecoObject>();

		internal readonly List<EItemType> itemTypes = new List<EItemType>();

		internal readonly List<string> errors = new List<string>();

		internal readonly List<string> warnings = new List<string>();

		public string BundleId { get; internal set; } = string.Empty;

		public string Name { get; internal set; } = string.Empty;

		public string JsonPath { get; internal set; } = string.Empty;

		public string BundlePath { get; internal set; } = string.Empty;

		public bool IsLoaded { get; internal set; }

		public bool IsValid { get; internal set; } = true;

		public IReadOnlyList<ECardExpansionType> ExpansionTypes => expansionTypes;

		public IReadOnlyList<EObjectType> FurnitureTypes => furnitureTypes;

		public IReadOnlyList<EDecoObject> DecoObjects => decoObjects;

		public IReadOnlyList<EItemType> ItemTypes => itemTypes;

		public IReadOnlyList<string> CeilingTextures => ceilingTextures;

		public IReadOnlyList<string> FloorTextures => floorTextures;

		public IReadOnlyList<string> WallTextures => wallTextures;

		public IReadOnlyList<string> Errors => errors;

		public IReadOnlyList<string> Warnings => warnings;
	}
	public enum DecoFlags
	{
		None,
		FloorTexture,
		WallTexture,
		CeilingTexture
	}
	public class ItemShopInfo
	{
		public string PhoneAppId { get; internal set; }

		public string AppDisplayName { get; internal set; }

		public RestockData? SmallBox { get; internal set; }

		public RestockData? BigBox { get; internal set; }
	}
	public class PackConfigData
	{
		public EItemType Pack { get; internal set; }

		public ECardExpansionType Expansion { get; internal set; }

		public ECollectionPackType PackType { get; internal set; }

		public bool CanHaveDuplicates { get; internal set; }

		public bool CanHaveGodPacks { get; internal set; }

		public float GodPackPercentage { get; internal set; }

		public string PackGenerationStrategy { get; internal set; } = string.Empty;
	}
	public class PackGeneratedEventArgs
	{
		public EItemType Pack { get; internal set; }

		public bool IsGodPack { get; internal set; }

		public List<CardData> Cards { get; internal set; }
	}
	public class PackGenerationEventArgs
	{
		public EItemType Pack { get; internal set; }

		public bool IsGodPack { get; internal set; }

		public Dictionary<ERarity, float>? NormalWeights { get; internal set; }

		public Dictionary<ERarity, float>? GodWeights { get; internal set; }

		public SortedDictionary<PackSlot, Dictionary<ERarity, float>>? SlotWeights { get; internal set; }
	}
	[Flags]
	public enum PackSlot : byte
	{
		None = 0,
		Slot1 = 1,
		Slot2 = 2,
		Slot3 = 4,
		Slot4 = 8,
		Slot5 = 0x10,
		Slot6 = 0x20,
		Slot7 = 0x40,
		All = 0x7F
	}
	public class PackWeightData
	{
		public IReadOnlyDictionary<ERarity, float> NormalWeights { get; internal set; }

		public IReadOnlyDictionary<ERarity, float> GodWeights { get; internal set; }

		public IReadOnlyDictionary<PackSlot, IReadOnlyDictionary<ERarity, float>> SlotWeights { get; internal set; }
	}
	public class ShopData
	{
		public string PhoneAppId { get; internal set; }

		public string AppDisplayName { get; internal set; }

		public IReadOnlyList<RestockData> TCG { get; internal set; }

		public IReadOnlyList<RestockData> Accessories { get; internal set; }

		public IReadOnlyList<RestockData> Figurines { get; internal set; }
	}
	public class StreamingAsset<T>(string bundlePath, string assetName) where T : Object
	{
		public string BundlePath { get; private set; } = bundlePath;

		public string AssetName { get; private set; } = assetName;

		internal string AssetKey => BundlePath + "|" + AssetName + "|" + typeof(T).Name;

		internal void GetAsync(Action<Object?> callback)
		{
			if (callback != null)
			{
				StreamingAssetsBridge.AssetLoadBridge?.StartLoadingCoroutine(BundlePath, AssetName, typeof(T), callback);
			}
		}
	}
}
namespace EnhancedPrefabLoader.API.InternalBridges
{
	internal interface IAssetLoadBridge
	{
		void StartLoadingCoroutine(string bundlePath, string assetName, Type type, Action<Object?> callback);
	}
	internal interface IAssetRefTracker
	{
		void IncrementRef(string assetKey);

		void DecrementRef(string assetKey);
	}
	internal static class StreamingAssetsBridge
	{
		internal static IAssetLoadBridge? AssetLoadBridge { get; set; }

		internal static IAssetRefTracker? AssetRefTracker { get; set; }
	}
}
namespace EnhancedPrefabLoader.API.Extensions
{
	public static class GameObjectExtensions
	{
		public static T GetOrAddComponent<T>(this GameObject obj) where T : Component
		{
			T result = default(T);
			if (!obj.TryGetComponent<T>(ref result))
			{
				return obj.AddComponent<T>();
			}
			return result;
		}
	}
	public static class StreamingAssetExtensions
	{
		private class AssetRequest
		{
			public string AssetName = string.Empty;

			public string RequestId = string.Empty;
		}

		private static readonly ConditionalWeakTable<Image, AssetRequest> activeSpriteRequests = new ConditionalWeakTable<Image, AssetRequest>();

		private static readonly ConditionalWeakTable<Material, Dictionary<string, AssetRequest>> activeTextureRequests = new ConditionalWeakTable<Material, Dictionary<string, AssetRequest>>();

		private static readonly ConditionalWeakTable<Material, Dictionary<string, string>> trackedTextureKeys = new ConditionalWeakTable<Material, Dictionary<string, string>>();

		public static void SetSpriteAsync(this Image image, StreamingAsset<Sprite>? asset)
		{
			if (asset == null)
			{
				image.CancelPendingSpriteAsync();
				image.sprite = null;
				return;
			}
			string requestId = Guid.NewGuid().ToString();
			AssetRequest orCreateValue = activeSpriteRequests.GetOrCreateValue(image);
			orCreateValue.AssetName = asset.AssetName;
			orCreateValue.RequestId = requestId;
			asset.GetAsync(delegate(Object? obj)
			{
				if (Object.op_Implicit((Object)(object)image))
				{
					Sprite val = (Sprite)(object)((obj is Sprite) ? obj : null);
					if (val != null && activeSpriteRequests.TryGetValue(image, out AssetRequest value) && !(value.RequestId != requestId) && !(value.AssetName != asset.AssetName))
					{
						((Component)image).gameObject.GetOrAddComponent<StreamingAssetTracker>().TrackImage(image, asset.AssetKey);
						image.sprite = val;
						((Graphic)image).SetAllDirty();
					}
				}
			});
		}

		public static void CancelPendingSpriteAsync(this Image image)
		{
			if (activeSpriteRequests.TryGetValue(image, out AssetRequest value))
			{
				value.RequestId = Guid.NewGuid().ToString();
				value.AssetName = string.Empty;
			}
			StreamingAssetTracker streamingAssetTracker = default(StreamingAssetTracker);
			if (((Component)image).TryGetComponent<StreamingAssetTracker>(ref streamingAssetTracker))
			{
				streamingAssetTracker.UntrackImage(image);
			}
		}

		public static void CancelPendingTextureAsync(this Material material, string propertyName)
		{
			if (activeTextureRequests.TryGetValue(material, out Dictionary<string, AssetRequest> value) && value.TryGetValue(propertyName, out var value2))
			{
				value2.RequestId = Guid.NewGuid().ToString();
				value2.AssetName = string.Empty;
			}
			UntrackTexture(material, propertyName);
		}

		public static void SetTextureAsync(this Material material, string propertyName, StreamingAsset<Texture>? asset)
		{
			if (asset == null)
			{
				material.CancelPendingTextureAsync(propertyName);
				material.SetTexture(propertyName, (Texture)null);
				return;
			}
			string requestId = Guid.NewGuid().ToString();
			Dictionary<string, AssetRequest> orCreateValue = activeTextureRequests.GetOrCreateValue(material);
			if (!orCreateValue.TryGetValue(propertyName, out var value))
			{
				value = new AssetRequest();
				orCreateValue[propertyName] = value;
			}
			value.AssetName = asset.AssetName;
			value.RequestId = requestId;
			asset.GetAsync(delegate(Object? obj)
			{
				if (Object.op_Implicit((Object)(object)material))
				{
					Texture val = (Texture)(object)((obj is Texture) ? obj : null);
					if (val != null && activeTextureRequests.TryGetValue(material, out Dictionary<string, AssetRequest> value2) && value2.TryGetValue(propertyName, out var value3) && !(value3.RequestId != requestId) && !(value3.AssetName != asset.AssetName))
					{
						TrackTexture(material, propertyName, asset.AssetKey);
						material.SetTexture(propertyName, val);
					}
				}
			});
		}

		private static void TrackTexture(Material material, string propertyName, string assetKey)
		{
			Dictionary<string, string> orCreateValue = trackedTextureKeys.GetOrCreateValue(material);
			if (orCreateValue.TryGetValue(propertyName, out string value))
			{
				StreamingAssetsBridge.AssetRefTracker?.DecrementRef(value);
			}
			orCreateValue[propertyName] = assetKey;
			StreamingAssetsBridge.AssetRefTracker?.IncrementRef(assetKey);
		}

		private static void UntrackTexture(Material material, string propertyName)
		{
			if (trackedTextureKeys.TryGetValue(material, out Dictionary<string, string> value) && value.TryGetValue(propertyName, out var value2))
			{
				StreamingAssetsBridge.AssetRefTracker?.DecrementRef(value2);
				value.Remove(propertyName);
			}
		}
	}
	public static class StringExtensions
	{
		public static T? TryParseToEnum<T>(this string value) where T : struct, Enum
		{
			if (!Enum.TryParse<T>(value, out var result))
			{
				return null;
			}
			return result;
		}

		public static string Sanitize(this string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "_Invalid";
			}
			string input = Regex.Replace(value, "\\s", "");
			input = Regex.Replace(input, "[^\\w]", "_");
			if (!string.IsNullOrEmpty(input) && !char.IsDigit(input[0]))
			{
				return input;
			}
			return "_" + input;
		}

		public static string Prettierize(this string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			value = value.Replace('_', ' ');
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(value[0]);
			for (int i = 1; i < value.Length; i++)
			{
				char c = value[i];
				char c2 = value[i - 1];
				if (char.IsUpper(c) && !char.IsWhiteSpace(c2) && (char.IsLower(c2) || (i < value.Length - 1 && char.IsLower(value[i + 1]))))
				{
					stringBuilder.Append(' ');
				}
				if (char.IsDigit(c) && char.IsLetter(c2))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(c);
			}
			return Regex.Replace(stringBuilder.ToString(), "\\s+", " ").Trim();
		}
	}
}
namespace EnhancedPrefabLoader.API.Events
{
	public interface IBundleEvents
	{
		event Action<string> OnBundleUninstalled;
	}
	public interface IEplEvents
	{
		IShopEvents Shops { get; }

		IItemEvents Items { get; }

		IBundleEvents Bundles { get; }

		event Action OnBundleLoadingComplete;
	}
	public interface IItemEvents
	{
		event Action<PackGenerationEventArgs> OnBeforePackGenerated;

		event Action<PackGeneratedEventArgs> OnAfterPackGenerated;
	}
	public interface IShopEvents
	{
		event Action OnShopsReady;
	}
}
namespace EnhancedPrefabLoader.API.Components
{
	internal class StreamingAssetTracker : MonoBehaviour
	{
		private readonly ConditionalWeakTable<Image, string> imageTracker = new ConditionalWeakTable<Image, string>();

		internal void TrackImage(Image image, string assetKey)
		{
			if (imageTracker.TryGetValue(image, out string value))
			{
				StreamingAssetsBridge.AssetRefTracker?.DecrementRef(value);
			}
			imageTracker.AddOrUpdate(image, assetKey);
			StreamingAssetsBridge.AssetRefTracker?.IncrementRef(assetKey);
		}

		internal void UntrackImage(Image image)
		{
			if (imageTracker.TryGetValue(image, out string value))
			{
				StreamingAssetsBridge.AssetRefTracker?.DecrementRef(value);
				imageTracker.Remove(image);
			}
		}

		private void OnDestroy()
		{
			foreach (var (_, assetKey) in (IEnumerable<KeyValuePair<Image, string>>)imageTracker)
			{
				StreamingAssetsBridge.AssetRefTracker?.DecrementRef(assetKey);
			}
		}
	}
}
namespace EnhancedPrefabLoader.API.Behaviors
{
	public interface ICardExpGenerator
	{
		float CalculateExp(CardData cardData);
	}
	public interface ICardPriceGenerator
	{
		float GenerateCardMarketPrice(ECardExpansionType expansionType, EMonsterType monsterType, ECardBorderType borderType, ERarity rarity, List<ERarity> expansionRarities, bool isFoil);
	}
	public interface IItemPriceGenerator
	{
		float GenerateItemCost(EItemType itemType, float baseCost);

		float GenerateItemMarketPrice(EItemType itemType, float baseCost, float minMarkup, float maxMarkup);
	}
	public interface IPackGenerator
	{
		List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils);
	}
}
namespace EnhancedPrefabLoader.API.Assets
{
	public interface ICardExpansionLibrary
	{
		StreamingAsset<Texture>? GetCardExpansionCardBack(ECardExpansionType cardExpansionType);

		StreamingAsset<Sprite>? GetCardExpansionFoilMask(ECardExpansionType cardExpansionType);

		StreamingAsset<Sprite>? GetCardFoilMask(ECardExpansionType cardExpansionType, EMonsterType monsterType);

		StreamingAsset<Texture>? GetCardBack(ECardExpansionType cardExpansionType, EMonsterType monsterType);

		StreamingAsset<Sprite>? GetCardSprite(ECardExpansionType cardExpansionType, EMonsterType monsterType);

		IReadOnlyDictionary<EMonsterType, StreamingAsset<Sprite>> GetCardSprites(ECardExpansionType cardExpansionType);

		MonsterData GetMonsterData(CardData cardData);

		MonsterData GetMonsterData(ECardExpansionType expansionType, EMonsterType monsterType);

		bool IsCardExpansionUnlocked(ECardExpansionType expansionType);

		bool IsCardFoil(ECardExpansionType expansionType, EMonsterType monsterType);
	}
	public interface IDecoLibrary
	{
		StreamingAsset<Sprite>? GetIcon(EDecoObject decoObject);

		IReadOnlyDictionary<EDecoObject, StreamingAsset<Sprite>> GetIcons();

		InteractableObject? GetPrefab(EDecoObject decoObject);

		IReadOnlyDictionary<EDecoObject, InteractableObject> GetPrefabs();

		int GetLevelRequirement(EDecoObject decoObject);
	}
	public interface IEplAssets
	{
		ICardExpansionLibrary CardExpansions { get; }

		IFurnitureLibrary Furniture { get; }

		IItemLibrary Items { get; }

		IDecoLibrary Deco { get; }

		IShopLibrary Shops { get; }
	}
	public interface IFurnitureLibrary
	{
		StreamingAsset<Sprite>? GetIcon(EObjectType objectType);

		IReadOnlyDictionary<EObjectType, StreamingAsset<Sprite>> GetIcons();

		InteractableObject? GetPrefab(EObjectType objectType);

		IReadOnlyDictionary<EObjectType, InteractableObject> GetPrefabs();

		int GetLevelRequirement(EObjectType objectType);
	}
	public interface IItemLibrary
	{
		StreamingAsset<Sprite>? GetIcon(EItemType itemType);

		IReadOnlyDictionary<EItemType, StreamingAsset<Sprite>> GetIcons();

		ItemMeshData? GetItemMeshData(EItemType itemType);

		IReadOnlyDictionary<EItemType, ItemMeshData> GetAllItemMeshData();

		EItemType GetBulkBox(ECardExpansionType expansionType, int priceCutoff);

		IReadOnlyDictionary<ECardExpansionType, IReadOnlyList<(int MinPrice, EItemType ItemType)>> GetBulkBoxes();

		PackWeightData GetPackWeights(EItemType pack);

		PackConfigData GetPackConfig(EItemType pack);

		EItemType? GetSpawnedPackType(EItemType cardBox);

		IReadOnlyList<EItemType> GetPacksForExpansion(ECardExpansionType expansionType);

		ECardExpansionType? GetExpansionForPackType(ECollectionPackType packType);
	}
	public interface IShopLibrary
	{
		IReadOnlyList<string> GetPhoneAppIds();

		ShopData? GetShopDataFor(string appId);

		ItemShopInfo? GetShopInfoFor(EItemType itemType);
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}