using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using Photon.Pun;
using UnityEngine;
using Zorro.Core;
using Zorro.Core.Serizalization;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RSMind.MysticalBackpack")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RSMind.MysticalBackpack")]
[assembly: AssemblyTitle("Mystical_Backpack")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Embedded]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Embedded]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace Microsoft.CodeAnalysis
{
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace MysticalBackpack
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("RSMind.MysticalBackpack", "Mystical_Backpack", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
internal static PeakBundle bundle;
public const string Id = "RSMind.MysticalBackpack";
internal static ManualLogSource Log { get; private set; }
public static string Name => "Mystical_Backpack";
public static string Version => "1.0.0";
private void Awake()
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)this, "mysticalbackpack.peakbundle", (Action<PeakBundle>)delegate(PeakBundle peakBundle)
{
peakBundle.Mod.RegisterContent();
bundle = peakBundle;
});
Harmony val = new Harmony("com.rsmind.peak.MysticalBackpack");
val.PatchAll();
Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
}
}
}
namespace MysticalBackpack.Patches
{
[HarmonyPatch(typeof(AirportCheckInKiosk), "Start")]
internal class AirportCheckInKioskStartPatch
{
private static void Postfix()
{
RunSettings.initialized = false;
RunSettings.Init();
}
}
[HarmonyPatch(typeof(BackpackData))]
public class BackpackDataPatches
{
[HarmonyPatch("Init")]
[HarmonyPrefix]
public static void InitPrefix(BackpackData __instance)
{
__instance.itemSlots = (ItemSlot[])(object)new ItemSlot[6];
}
[HarmonyPatch("DeserializeValue")]
[HarmonyPrefix]
public static bool DesserializeValuePrefix(BackpackData __instance, BinaryDeserializer deserializer)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
InventorySyncData val = default(InventorySyncData);
((InventorySyncData)(ref val)).Deserialize(deserializer);
Item val2 = null;
for (byte b = 0; b < __instance.itemSlots.Length; b++)
{
if (__instance.itemSlots[b] == null)
{
__instance.itemSlots[b] = new ItemSlot(b);
}
__instance.itemSlots[b].SetItem(ItemDatabase.TryGetItem(val.slots[b].ItemID, ref val2) ? val2 : null, val.slots[b].Data);
Debug.Log((object)$"Sync Back Inventory is setting slot: {b} to {__instance.itemSlots[b]}");
}
return false;
}
}
[HarmonyPatch(typeof(BackpackSlot), "GetPrefabName")]
internal class BackpackSlotGetPrefabNamePatch
{
private static void Postfix(BackpackSlot __instance, ref string __result)
{
if (((Object)((ItemSlot)__instance)._prefab).name.Contains("AntiPack"))
{
__result = "RSMind.MysticalBackpack:AntiPack";
}
}
}
[HarmonyPatch(typeof(BackpackVisuals))]
public class BackpackVisualsPatches
{
[HarmonyPrefix]
[HarmonyPatch("RefreshVisuals")]
public static bool RefreshVisualsPrefix(BackpackVisuals __instance)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Invalid comparison between Unknown and I4
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Invalid comparison between Unknown and I4
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Invalid comparison between Unknown and I4
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0129: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance.backpack != (Object)null && (int)__instance.backpack.backpackType != 1 && (int)__instance.backpack.backpackType != 2 && (int)__instance.backpack.backpackType != 3)
{
return true;
}
BackpackData backpackData = __instance.GetBackpackData();
if (backpackData == null)
{
Debug.LogWarning((object)"BackpackData is null, cannot refresh visuals.");
return true;
}
int num = backpackData.itemSlots.Length;
if (__instance.backpackSlots.Length < num)
{
int num2 = Mathf.Max(__instance.backpackSlots.Length, num);
Transform[] backpackSlots = __instance.backpackSlots;
Transform[] array = (Transform[])(object)new Transform[num2];
for (int i = 0; i < backpackSlots.Length; i++)
{
array[i] = backpackSlots[i];
}
for (int j = backpackSlots.Length; j < num2; j++)
{
array[j] = array[j % 4];
}
__instance.backpackSlots = array;
}
for (byte b = 0; b < num; b++)
{
try
{
ItemSlot val = backpackData.itemSlots[b];
Optionable<ushort> val2 = (((Object)(object)val.prefab == (Object)null) ? Optionable<ushort>.None : Optionable<ushort>.Some(val.prefab.itemID));
(GameObject, ushort) value;
Optionable<ushort> val3 = (__instance.visualItems.TryGetValue(b, out value) ? Optionable<ushort>.Some(value.Item2) : Optionable<ushort>.None);
if (val2 != val3)
{
if (val2.IsSome && val3.IsSome)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogError((object)$"Item Visuals Mismatch at slot {b}!");
}
}
else if (val2.IsSome && val3.IsNone)
{
Debug.Log((object)$"Spawning Backpack Visual for slot {b}, itemID {val2.Value}");
GameObject val4 = null;
try
{
val4 = PhotonNetwork.Instantiate("0_Items/" + val.GetPrefabName(), new Vector3(0f, -500f, 0f), Quaternion.identity, (byte)0, (object[])null);
__instance.PutItemInBackpack(val4, b);
val4.GetComponent<PhotonView>().RPC("SetItemInstanceDataRPC", (RpcTarget)0, new object[1] { val.data });
__instance.visualItems.Add(b, (val4, val2.Value));
}
catch (Exception arg)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogError((object)$"Failed to spawn visual for slot {b}: {arg}");
}
}
}
else if (val2.IsNone && val3.IsSome)
{
Debug.Log((object)$"Removing backpack visual for slot {b}, itemID {val3.Value}");
if (__instance.visualItems.TryGetValue(b, out (GameObject, ushort) value2) && (Object)(object)value2.Item1 != (Object)null)
{
try
{
PhotonNetwork.Destroy(value2.Item1.GetComponent<PhotonView>());
}
catch (Exception arg2)
{
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogError((object)$"Failed to destroy visual for slot {b}: {arg2}");
}
}
__instance.visualItems.Remove(b);
}
else
{
Debug.LogWarning((object)$"No valid visual object to remove for slot {b}");
}
}
}
else if (val2.IsNone)
{
Debug.Log((object)$"Slot {b} is empty, no visual to spawn.");
}
}
catch (Exception arg3)
{
ManualLogSource log4 = Plugin.Log;
if (log4 != null)
{
log4.LogError((object)$"Exception refreshing slot {b}: {arg3}");
}
}
}
return false;
}
}
[HarmonyPatch(typeof(BackpackWheel))]
public class BackpackWheelPatches
{
[HarmonyPatch("InitWheel")]
[HarmonyPrefix]
private static void InitWheelPrefix(BackpackWheel __instance, ref BackpackReference bp, ref int slotCount, BackpackType backpackType)
{
//IL_019a: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_0217: Unknown result type (might be due to invalid IL or missing references)
//IL_0230: Unknown result type (might be due to invalid IL or missing references)
//IL_025a: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Expected O, but got Unknown
int num = 6;
int num2 = num + 1;
int num3 = __instance.slices.Length;
ItemSlot[] itemSlots = ((BackpackReference)(ref bp)).GetData().itemSlots;
if (num3 < num2)
{
BackpackWheelSlice val = __instance.slices[1];
BackpackWheelSlice[] slices = __instance.slices;
List<BackpackWheelSlice> list = new List<BackpackWheelSlice>(slices.Length);
list.AddRange(slices);
while (list.Count < num2)
{
BackpackWheelSlice item = Object.Instantiate<BackpackWheelSlice>(val, ((Component)val).transform.parent);
list.Add(item);
}
__instance.slices = list.ToArray();
}
else if (num3 > num2)
{
for (int i = num2; i < num3; i++)
{
Object.Destroy((Object)(object)((Component)__instance.slices[i]).gameObject);
}
List<BackpackWheelSlice> list2 = new List<BackpackWheelSlice>();
list2.AddRange(__instance.slices.Take(num2));
__instance.slices = list2.ToArray();
}
if (itemSlots.Length < num)
{
ItemSlot[] array = (ItemSlot[])(object)new ItemSlot[num];
for (int j = 0; j < itemSlots.Length; j++)
{
array[j] = itemSlots[j];
}
for (int k = itemSlots.Length; k < num; k++)
{
array[k] = new ItemSlot((byte)k);
}
((BackpackReference)(ref bp)).GetData().itemSlots = array;
}
else if (itemSlots.Length > num)
{
BackpackData data = ((BackpackReference)(ref bp)).GetData();
List<ItemSlot> list3 = new List<ItemSlot>();
list3.AddRange(itemSlots.Take(num));
data.itemSlots = list3.ToArray();
}
num3 = slotCount + 1;
float num4 = (num3 - 4) * 36;
Transform parent = ((Component)__instance.slices[0]).transform.parent;
parent.position = new Vector3((float)Screen.width / 2f, (float)Screen.height / 2f, 0f);
parent.rotation = Quaternion.Euler(0f, 0f, 0f);
for (int l = 0; l < num3; l++)
{
BackpackWheelSlice val2 = __instance.slices[l];
Transform transform = ((Component)val2.image).transform;
float num5 = 360f / (float)num3 * (float)l + 158f;
float num6 = (num5 + 112f) * (MathF.PI / 180f);
((Component)val2).transform.localRotation = Quaternion.Euler(0f, 0f, num5);
transform.localRotation = Quaternion.Euler(0f, 0f, 0f - num5);
((Component)val2).transform.localPosition = new Vector3(Mathf.Cos(num6) * num4, Mathf.Sin(num6) * num4, 0f);
}
}
}
[HarmonyPatch(typeof(BackpackWheelSlice), "SharedInit")]
internal class BackpackWheelSliceSharedInitPatch
{
private static void Postfix(BackpackWheelSlice __instance, BackpackReference bpRef, BackpackWheel wheel)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
if (((Object)bpRef.view).name.Contains("AntiPack") && (int)bpRef.type == 0)
{
Backpack component = Plugin.bundle.LoadAsset<GameObject>("AntiPack").GetComponent<Backpack>();
if (__instance.backpackSlot == byte.MaxValue)
{
((Component)__instance).gameObject.SetActive(true);
}
__instance.SetItemIcon((Item)(object)component, (ItemInstanceData)null);
}
}
}
[HarmonyPatch(typeof(CharacterBackpackHandler))]
internal class CharacterBackpackHandlerPatches
{
[HarmonyPatch("Awake")]
[HarmonyPostfix]
private static void awakePatch(CharacterBackpackHandler __instance)
{
Transform parent = ((Component)__instance.backpackVisuals).transform.parent;
Object.Instantiate<GameObject>(Plugin.bundle.LoadAsset<GameObject>("OnBack_AntiPack"), parent);
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPostfix]
private static void activeBackpackVisualsGetterPatch(CharacterBackpackHandler __instance, ref BackpackOnBackVisuals __result)
{
if (!((Object)(object)((ItemSlot)__instance.character.player.backpackSlot)._prefab == (Object)null) && ((Object)((ItemSlot)__instance.character.player.backpackSlot)._prefab).name.Contains("AntiPack"))
{
__result = ((Component)((Component)__instance.backpackVisuals).transform.parent.Find("OnBack_AntiPack(Clone)")).GetComponent<BackpackOnBackVisuals>();
}
}
[HarmonyPatch("LateUpdate")]
[HarmonyPostfix]
private static void lateUpdatePatch(CharacterBackpackHandler __instance)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Invalid comparison between Unknown and I4
bool flag = (int)__instance.character.player.backpackSlot.backpackType > 0;
bool flag2 = __instance.characterItems.currentSelectedSlot.IsSome && __instance.characterItems.currentSelectedSlot.Value == 3;
if (!flag || flag2 || (((MonoBehaviourPun)__instance.character).photonView.IsMine && !MainCameraMovement.IsSpectating))
{
((Component)((Component)__instance.backpackVisuals).transform.parent.Find("OnBack_AntiPack(Clone)")).GetComponent<BackpackOnBackVisuals>().SetViewActive(false);
}
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ConstantExpectedAttribute : Attribute
{
public object? Min { get; set; }
public object? Max { get; set; }
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ExperimentalAttribute : Attribute
{
public string DiagnosticId { get; }
public string? UrlFormat { get; set; }
public ExperimentalAttribute(string diagnosticId)
{
DiagnosticId = diagnosticId;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
internal sealed class MemberNotNullAttribute : Attribute
{
public string[] Members { get; }
public MemberNotNullAttribute(string member)
{
Members = new string[1] { member };
}
public MemberNotNullAttribute(params string[] members)
{
Members = members;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
internal sealed class MemberNotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public string[] Members { get; }
public MemberNotNullWhenAttribute(bool returnValue, string member)
{
ReturnValue = returnValue;
Members = new string[1] { member };
}
public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
{
ReturnValue = returnValue;
Members = members;
}
}
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class SetsRequiredMembersAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class StringSyntaxAttribute : Attribute
{
public const string CompositeFormat = "CompositeFormat";
public const string DateOnlyFormat = "DateOnlyFormat";
public const string DateTimeFormat = "DateTimeFormat";
public const string EnumFormat = "EnumFormat";
public const string GuidFormat = "GuidFormat";
public const string Json = "Json";
public const string NumericFormat = "NumericFormat";
public const string Regex = "Regex";
public const string TimeOnlyFormat = "TimeOnlyFormat";
public const string TimeSpanFormat = "TimeSpanFormat";
public const string Uri = "Uri";
public const string Xml = "Xml";
public string Syntax { get; }
public object?[] Arguments { get; }
public StringSyntaxAttribute(string syntax)
{
Syntax = syntax;
Arguments = new object[0];
}
public StringSyntaxAttribute(string syntax, params object?[] arguments)
{
Syntax = syntax;
Arguments = arguments;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class UnscopedRefAttribute : Attribute
{
}
}
namespace System.Runtime.Versioning
{
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class RequiresPreviewFeaturesAttribute : Attribute
{
public string? Message { get; }
public string? Url { get; set; }
public RequiresPreviewFeaturesAttribute()
{
}
public RequiresPreviewFeaturesAttribute(string? message)
{
Message = message;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CallerArgumentExpressionAttribute : Attribute
{
public string ParameterName { get; }
public CallerArgumentExpressionAttribute(string parameterName)
{
ParameterName = parameterName;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CollectionBuilderAttribute : Attribute
{
public Type BuilderType { get; }
public string MethodName { get; }
public CollectionBuilderAttribute(Type builderType, string methodName)
{
BuilderType = builderType;
MethodName = methodName;
}
}
[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CompilerFeatureRequiredAttribute : Attribute
{
public const string RefStructs = "RefStructs";
public const string RequiredMembers = "RequiredMembers";
public string FeatureName { get; }
public bool IsOptional { get; set; }
public CompilerFeatureRequiredAttribute(string featureName)
{
FeatureName = featureName;
}
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
{
public string[] Arguments { get; }
public InterpolatedStringHandlerArgumentAttribute(string argument)
{
Arguments = new string[1] { argument };
}
public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
{
Arguments = arguments;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class InterpolatedStringHandlerAttribute : Attribute
{
}
[EditorBrowsable(EditorBrowsableState.Never)]
[ExcludeFromCodeCoverage]
internal static class IsExternalInit
{
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ModuleInitializerAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class OverloadResolutionPriorityAttribute : Attribute
{
public int Priority { get; }
public OverloadResolutionPriorityAttribute(int priority)
{
Priority = priority;
}
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
[ExcludeFromCodeCoverage]
internal sealed class ParamCollectionAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class RequiredMemberAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[ExcludeFromCodeCoverage]
internal sealed class RequiresLocationAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class SkipLocalsInitAttribute : Attribute
{
}
}
