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 System.Text;
using BepInEx;
using BepInEx.Logging;
using ContractQueen.Behaviors;
using ContractQueen.ContractEvents;
using ContractQueen.ContractManager;
using ContractQueen.Contracts;
using ContractQueen.Patches;
using ContractQueen.Persist;
using FrogDataLib.DataManagement;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using Unity.VisualScripting;
using UnityEngine;
using YAPYAP;
using YAPYAP.Npc.Frog;
using YapLocalizer;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("dev.mamallama.contractqueen")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.3.2.0")]
[assembly: AssemblyInformationalVersion("0.3.2+dba98a7cfc5d038db297582d2de3ec532f794d35")]
[assembly: AssemblyProduct("dev.mamallama.contractqueen")]
[assembly: AssemblyTitle("ContractQueen")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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")]
	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")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace ContractQueen
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("dev.mamallama.contractqueen", "ContractQueen", "0.3.2")]
	public class ContractQueenPlugin : BaseUnityPlugin
	{
		internal const string contractName = "CONTRACT_QUEEN_TEST_CONTRACT_NAME";

		internal const string contractDesc = "CONTRACT_QUEEN_TEST_CONTRACT_DESC";

		internal static FrogDataContainerSimple<FrogDatabaseDTO> container;

		public const string Id = "dev.mamallama.contractqueen";

		internal static ManualLogSource Log { get; private set; }

		internal static FrogDatabaseDTO Database => container.Data;

		public static string Name => "ContractQueen";

		public static string Version => "0.3.2";

		private void Awake()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogMessage((object)"Loading localized contract data");
			ModLocalizedText val = new ModLocalizedText("CONTRACT_QUEEN_TEST_CONTRACT_NAME", "");
			val.SetLocalization((SystemLanguage)10, "Rescue Frogs");
			val = new ModLocalizedText("CONTRACT_QUEEN_TEST_CONTRACT_DESC", "");
			val.SetLocalization((SystemLanguage)10, "Rescued {0}/{1} Frogs");
			Harmony val2 = new Harmony("dev.mamallama.contractqueen");
			val2.PatchAll(typeof(DungeonTasksPatches));
			val2.PatchAll(typeof(NetworkPuppetPropPatches));
			val2.PatchAll(typeof(FrogStateMachinePatches));
			container = new FrogDataContainerSimple<FrogDatabaseDTO>("dev.mamallama.contractqueen");
			Log.LogInfo((object)$"Patch count: {val2.GetPatchedMethods().Count()}");
			ContractsModule contractsModule = new ContractsModule("dev.mamallama.contractqueen");
			contractsModule.RegisterContract("RescueFrogsQuest", (GameplayTaskSO)(object)RescueFrogsTask.Create());
		}
	}
}
namespace ContractQueen.Persist
{
	[Serializable]
	public class FrogDatabaseDTO : FrogDataModel
	{
		internal Dictionary<AssetMUD, FrogDataDTO> AssetLookupTable = new Dictionary<AssetMUD, FrogDataDTO>();

		[SerializeField]
		public List<FrogDataDTO> FrogData;

		public FrogDatabaseDTO()
		{
			FrogData = new List<FrogDataDTO>();
		}

		public FrogDataDTO GetFrogData(AssetMUD mud)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (AssetLookupTable.TryGetValue(mud, out FrogDataDTO value))
			{
				ContractQueenPlugin.Log.LogDebug((object)("Mapped a DTO for frog: " + ((AssetMUD)(ref mud)).GetDigest()));
				return value;
			}
			FrogDataDTO frogDataDTO = new FrogDataDTO
			{
				MUDToken = mud.Identifier
			};
			FrogData.Add(frogDataDTO);
			ContractQueenPlugin.Log.LogDebug((object)"Created a new DTO for a frog");
			return frogDataDTO;
		}

		public override void OnAfterSerialize()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			ContractQueenPlugin.Log.LogDebug((object)$"Received serialization callback, {FrogData.Count} items in list");
			AssetLookupTable.Clear();
			foreach (FrogDataDTO frogDatum in FrogData)
			{
				AssetLookupTable[new AssetMUD(frogDatum.MUDToken)] = frogDatum;
			}
		}

		public override void OnBeforeSerialize()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			ContractQueenPlugin.Log.LogDebug((object)"Saving all FrogContractBehaviors");
			FrogData.Clear();
			FrogContractBehavior[] array = Object.FindObjectsByType<FrogContractBehavior>((FindObjectsInactive)0, (FindObjectsSortMode)0);
			FrogContractBehavior[] array2 = array;
			AssetMUD val = default(AssetMUD);
			foreach (FrogContractBehavior frogContractBehavior in array2)
			{
				((AssetMUD)(ref val))..ctor((NetworkBehaviour)(object)((Component)frogContractBehavior).GetComponent<FrogStateMachine>());
				frogContractBehavior.Data.MUDToken = val.Identifier;
				ContractQueenPlugin.Log.LogDebug((object)("Saved a DTO for frog:" + ((AssetMUD)(ref val)).GetDigest()));
				FrogData.Add(frogContractBehavior.Data);
			}
		}
	}
	[Serializable]
	public class FrogDataDTO
	{
		[SerializeField]
		public string MUDToken = string.Empty;

		[SerializeField]
		public bool HasBeenCounted;
	}
}
namespace ContractQueen.Patches
{
	internal class DungeonTasksPatches
	{
		[HarmonyPatch(typeof(DungeonTasks), "PreAwake")]
		[HarmonyPostfix]
		internal static void AddContractsToRandomPool()
		{
			ContractsRegistry.Lock();
			IReadOnlyList<GameplayTaskSO> lockedList = ContractsRegistry.LockedList;
			GameplayTaskSO[] frozenConstants = ContractsRegistry.FrozenConstants;
			GameplayTaskSO[] frozenRandoms = ContractsRegistry.FrozenRandoms;
			GameplayTaskSO[] frozenCollectibles = ContractsRegistry.FrozenCollectibles;
			int num = frozenConstants.Length + frozenRandoms.Length + frozenCollectibles.Length;
			int num2 = 0;
			foreach (GameplayTaskSO item in lockedList)
			{
				item.TaskId = num + num2;
				num2++;
			}
			DungeonTasks instance = DungeonTasks.Instance;
			GameplayTaskSO[] array = frozenRandoms;
			IReadOnlyList<GameplayTaskSO> readOnlyList = lockedList;
			int num3 = 0;
			GameplayTaskSO[] array2 = (GameplayTaskSO[])(object)new GameplayTaskSO[array.Length + readOnlyList.Count];
			ReadOnlySpan<GameplayTaskSO> readOnlySpan = new ReadOnlySpan<GameplayTaskSO>(array);
			readOnlySpan.CopyTo(new Span<GameplayTaskSO>(array2).Slice(num3, readOnlySpan.Length));
			num3 += readOnlySpan.Length;
			foreach (GameplayTaskSO item2 in readOnlyList)
			{
				array2[num3] = item2;
				num3++;
			}
			instance.randomTasks = array2;
			DungeonTasks instance2 = DungeonTasks.Instance;
			List<GameplayTaskSO> list = new List<GameplayTaskSO>();
			list.AddRange(frozenConstants);
			list.AddRange(frozenRandoms);
			list.AddRange(frozenCollectibles);
			list.AddRange(lockedList);
			instance2.allTasks = list.ToArray();
			ContractQueenPlugin.Log.LogMessage((object)$"Added {num2} contract(s) to pool starting from ID {num} to {num + num2 - 1}");
		}
	}
	internal static class FrogStateMachinePatches
	{
		[HarmonyPatch(typeof(FrogStateMachine), "Awake")]
		[HarmonyPostfix]
		internal static void AwakePatch(FrogStateMachine __instance)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)((Component)__instance).gameObject).GetInstanceID() <= 0)
			{
				FrogContractBehavior frogContractBehavior = ComponentHolderProtocol.AddComponent<FrogContractBehavior>((Object)(object)__instance);
				AssetMUD mud = default(AssetMUD);
				((AssetMUD)(ref mud))..ctor((NetworkBehaviour)(object)__instance);
				FrogDataDTO frogData = ContractQueenPlugin.Database.GetFrogData(mud);
				frogContractBehavior.Data = frogData;
			}
		}
	}
	internal static class NetworkPuppetPropPatches
	{
		[HarmonyPatch(typeof(NetworkPuppetProp), "OnDropped")]
		[HarmonyPostfix]
		internal static void ServerSetInInventoryPatch(NetworkPuppetProp __instance)
		{
			FrogContractBehavior component = ((Component)__instance).GetComponent<FrogContractBehavior>();
			ContractQueenPlugin.Log.LogDebug((object)$"OnDropped: {((Object)((Component)__instance).gameObject).name} | {__instance.DisplayName}({((Object)__instance).GetInstanceID()}), isFrog: {(Object)(object)component != (Object)null}");
			if (!((Object)(object)component == (Object)null) && !component.HasBeenCounted)
			{
				ContractQueenPlugin.Log.LogDebug((object)$"New frog: {!component.HasBeenCounted}");
				Events.CountFrog(component);
			}
		}
	}
}
namespace ContractQueen.Contracts
{
	public class RescueFrogsTask : GameplayTaskSO
	{
		[SerializeField]
		private int frogCount = 3;

		public static RescueFrogsTask Create()
		{
			RescueFrogsTask rescueFrogsTask = ScriptableObject.CreateInstance<RescueFrogsTask>();
			((GameplayTaskSO)rescueFrogsTask).nameLocalisationKey = "CONTRACT_QUEEN_TEST_CONTRACT_NAME";
			((GameplayTaskSO)rescueFrogsTask).descriptionLocalisationKey = "CONTRACT_QUEEN_TEST_CONTRACT_DESC";
			((GameplayTaskSO)rescueFrogsTask).pointValue = 300;
			return rescueFrogsTask;
		}

		public override bool CanBeCreated()
		{
			return true;
		}

		protected override int CalculateTargetProgress()
		{
			return frogCount;
		}

		public override void SubscribeToProgressEvents(GameplayTask runtimeTask)
		{
			GameplayTask runtimeTask2 = runtimeTask;
			Action<FrogContractBehavior> action = delegate
			{
				ContractQueenPlugin.Log.LogDebug((object)"Counted a frog for a quest");
				runtimeTask2.AdvanceProgress(1);
			};
			runtimeTask2.SetProgressHandler((Delegate)action);
			Events.FrogCountedEvent += action;
		}

		public override void UnsubscribeFromProgressEvents(GameplayTask runtimeTask)
		{
			if (runtimeTask.GetProgressHandler() is Action<FrogContractBehavior> value)
			{
				Events.FrogCountedEvent -= value;
				runtimeTask.SetProgressHandler((Delegate)null);
			}
		}
	}
}
namespace ContractQueen.ContractManager
{
	public class ContractBundle
	{
		public readonly string Name;

		public readonly GameplayTaskSO Contract;

		public ContractBundle(string name, GameplayTaskSO contract)
		{
			Name = name;
			Contract = contract;
			base..ctor();
		}
	}
	internal class ContractBundleComparer : IComparer<ContractBundle>
	{
		public static readonly IComparer<ContractBundle> NameOrdinal = new ContractBundleComparer();

		public int Compare(ContractBundle x, ContractBundle y)
		{
			if (x == y)
			{
				return 0;
			}
			if (x == null)
			{
				return -1;
			}
			if (y == null)
			{
				return 1;
			}
			return StringComparer.Ordinal.Compare(x.Name, y.Name);
		}
	}
	public sealed class ContractsModule
	{
		private readonly string GUID;

		private readonly SortedSet<ContractBundle> _contracts;

		public ContractsModule(string guid)
		{
			GUID = guid;
			_contracts = ContractsRegistry.EnsureGUID(GUID);
		}

		public bool RegisterContract(ContractBundle contract)
		{
			return _contracts.Add(contract);
		}

		public bool RegisterContract(string name, GameplayTaskSO contract)
		{
			return _contracts.Add(new ContractBundle(name, contract));
		}

		public void RegisterMany(IEnumerable<ContractBundle> items)
		{
			LinqUtility.AddRange<ContractBundle>((ICollection<ContractBundle>)_contracts, items);
		}
	}
	internal static class ContractsRegistry
	{
		private static readonly SortedDictionary<string, SortedSet<ContractBundle>> Registry = new SortedDictionary<string, SortedSet<ContractBundle>>(StringComparer.Ordinal);

		private static bool Finalized = false;

		private static IReadOnlyList<GameplayTaskSO> _cachedLockedList = Array.Empty<GameplayTaskSO>();

		internal static GameplayTaskSO[] FrozenConstants { get; private set; } = Array.Empty<GameplayTaskSO>();


		internal static GameplayTaskSO[] FrozenCollectibles { get; private set; } = Array.Empty<GameplayTaskSO>();


		internal static GameplayTaskSO[] FrozenRandoms { get; private set; } = Array.Empty<GameplayTaskSO>();


		public static IReadOnlyList<GameplayTaskSO> LockedList => _cachedLockedList;

		internal static SortedSet<ContractBundle> EnsureGUID(string GUID)
		{
			if (Finalized)
			{
				throw new InvalidOperationException("Cannot add quests after main menu is reached");
			}
			if (Registry.TryGetValue(GUID, out SortedSet<ContractBundle> value))
			{
				return value;
			}
			SortedSet<ContractBundle> sortedSet = new SortedSet<ContractBundle>(ContractBundleComparer.NameOrdinal);
			Registry[GUID] = sortedSet;
			return sortedSet;
		}

		internal static void Lock()
		{
			try
			{
				List<GameplayTaskSO> list = new List<GameplayTaskSO>();
				foreach (SortedSet<ContractBundle> value in Registry.Values)
				{
					foreach (ContractBundle item in value)
					{
						list.Add(item.Contract);
					}
				}
				FrozenConstants = DungeonTasks.Instance.constantTasks;
				FrozenRandoms = DungeonTasks.Instance.randomTasks;
				FrozenCollectibles = DungeonTasks.Instance.collectableTasks;
				ContractQueenPlugin.Log.LogMessage((object)ListContracts());
				_cachedLockedList = list.AsReadOnly();
				Finalized = true;
			}
			catch (Exception ex)
			{
				ContractQueenPlugin.Log.LogError((object)(ex.Message + "\n\n" + ex.StackTrace));
			}
		}

		public static string ListContracts()
		{
			StringBuilder stringBuilder = new StringBuilder("Contracts Loaded:\n");
			foreach (KeyValuePair<string, SortedSet<ContractBundle>> item in Registry)
			{
				stringBuilder.AppendLine("  [" + item.Key + "]");
				foreach (ContractBundle item2 in item.Value)
				{
					stringBuilder.AppendLine("    -" + item2.Name);
				}
			}
			return stringBuilder.ToString();
		}
	}
}
namespace ContractQueen.ContractEvents
{
	public static class Events
	{
		public static event Action<FrogContractBehavior>? FrogCountedEvent;

		internal static void CountFrog(FrogContractBehavior frog)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if ((int)GameManager.Instance.CurrentGameState == 0)
			{
				Events.FrogCountedEvent?.Invoke(frog);
			}
			frog.Count();
		}
	}
}
namespace ContractQueen.Behaviors
{
	public class FrogContractBehavior : MonoBehaviour
	{
		public FrogDataDTO Data;

		public NetworkPuppetProp Owner { get; protected set; }

		public bool HasBeenCounted => Data.HasBeenCounted;

		private void Awake()
		{
			Owner = ((Component)this).gameObject.GetComponent<NetworkPuppetProp>();
			if ((Object)(object)Owner == (Object)null)
			{
				ContractQueenPlugin.Log.LogError((object)"Unable to establish owner in FrogContractBehavior");
			}
		}

		public void Count()
		{
			Data.HasBeenCounted = true;
		}
	}
}
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
	{
		internal 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
	{
	}
}