using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.Text;
using Cpp2IlInjected;

namespace System.ComponentModel
{
	/// <summary>Represents a mask-parsing service that can be used by any number of controls that support masking, such as the <see cref="T:System.Windows.Forms.MaskedTextBox" /> control.</summary>
	// Token: 0x02000163 RID: 355
	[Token(Token = "0x2000163")]
	public class MaskedTextProvider : ICloneable
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask.</summary>
		/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
		// Token: 0x06000891 RID: 2193 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000891")]
		[Address(RVA = "0xC63AB0", Offset = "0xC62AB0", VA = "0x180C63AB0")]
		public MaskedTextProvider(string mask)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask and ASCII restriction value.</summary>
		/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
		/// <param name="restrictToAscii">
		///   <see langword="true" /> to restrict input to ASCII-compatible characters; otherwise <see langword="false" /> to allow the entire Unicode set.</param>
		// Token: 0x06000892 RID: 2194 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000892")]
		[Address(RVA = "0xC639D0", Offset = "0xC629D0", VA = "0x180C639D0")]
		public MaskedTextProvider(string mask, bool restrictToAscii)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask and culture.</summary>
		/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
		/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
		// Token: 0x06000893 RID: 2195 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000893")]
		[Address(RVA = "0xC63A80", Offset = "0xC62A80", VA = "0x180C63A80")]
		public MaskedTextProvider(string mask, CultureInfo culture)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, culture, and ASCII restriction value.</summary>
		/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
		/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
		/// <param name="restrictToAscii">
		///   <see langword="true" /> to restrict input to ASCII-compatible characters; otherwise <see langword="false" /> to allow the entire Unicode set.</param>
		// Token: 0x06000894 RID: 2196 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000894")]
		[Address(RVA = "0xC639A0", Offset = "0xC629A0", VA = "0x180C639A0")]
		public MaskedTextProvider(string mask, CultureInfo culture, bool restrictToAscii)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, password character, and prompt usage value.</summary>
		/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
		/// <param name="passwordChar">A <see cref="T:System.Char" /> that will be displayed for characters entered into a password string.</param>
		/// <param name="allowPromptAsInput">
		///   <see langword="true" /> to allow the prompt character as input; otherwise <see langword="false" />.</param>
		// Token: 0x06000895 RID: 2197 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000895")]
		[Address(RVA = "0xC63A10", Offset = "0xC62A10", VA = "0x180C63A10")]
		public MaskedTextProvider(string mask, char passwordChar, bool allowPromptAsInput)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, culture, password character, and prompt usage value.</summary>
		/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
		/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
		/// <param name="passwordChar">A <see cref="T:System.Char" /> that will be displayed for characters entered into a password string.</param>
		/// <param name="allowPromptAsInput">
		///   <see langword="true" /> to allow the prompt character as input; otherwise <see langword="false" />.</param>
		// Token: 0x06000896 RID: 2198 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000896")]
		[Address(RVA = "0xC63A40", Offset = "0xC62A40", VA = "0x180C63A40")]
		public MaskedTextProvider(string mask, CultureInfo culture, char passwordChar, bool allowPromptAsInput)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.MaskedTextProvider" /> class using the specified mask, culture, prompt usage value, prompt character, password character, and ASCII restriction value.</summary>
		/// <param name="mask">A <see cref="T:System.String" /> that represents the input mask.</param>
		/// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" /> that is used to set region-sensitive separator characters.</param>
		/// <param name="allowPromptAsInput">A <see cref="T:System.Boolean" /> value that specifies whether the prompt character should be allowed as a valid input character.</param>
		/// <param name="promptChar">A <see cref="T:System.Char" /> that will be displayed as a placeholder for user input.</param>
		/// <param name="passwordChar">A <see cref="T:System.Char" /> that will be displayed for characters entered into a password string.</param>
		/// <param name="restrictToAscii">
		///   <see langword="true" /> to restrict input to ASCII-compatible characters; otherwise <see langword="false" /> to allow the entire Unicode set.</param>
		/// <exception cref="T:System.ArgumentException">The mask parameter is <see langword="null" /> or <see cref="F:System.String.Empty" />.  
		///  -or-  
		///  The mask contains one or more non-printable characters.</exception>
		// Token: 0x06000897 RID: 2199 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000897")]
		[Address(RVA = "0xC63AE0", Offset = "0xC62AE0", VA = "0x180C63AE0")]
		public MaskedTextProvider(string mask, CultureInfo culture, bool allowPromptAsInput, char promptChar, char passwordChar, bool restrictToAscii)
		{
		}

		// Token: 0x06000898 RID: 2200 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x6000898")]
		[Address(RVA = "0xC5FB30", Offset = "0xC5EB30", VA = "0x180C5FB30")]
		private void Initialize()
		{
		}

		/// <summary>Gets a value indicating whether the prompt character should be treated as a valid input character or not.</summary>
		/// <returns>
		///   <see langword="true" /> if the user can enter <see cref="P:System.ComponentModel.MaskedTextProvider.PromptChar" /> into the control; otherwise, <see langword="false" />. The default is <see langword="true" />.</returns>
		// Token: 0x170001A2 RID: 418
		// (get) Token: 0x06000899 RID: 2201 RVA: 0x00005388 File Offset: 0x00003588
		[Token(Token = "0x170001A2")]
		public bool AllowPromptAsInput
		{
			[Token(Token = "0x6000899")]
			[Address(RVA = "0xC63EE0", Offset = "0xC62EE0", VA = "0x180C63EE0")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets the number of editable character positions that have already been successfully assigned an input value.</summary>
		/// <returns>An <see cref="T:System.Int32" /> containing the number of editable character positions in the input mask that have already been assigned a character value in the formatted string.</returns>
		// Token: 0x170001A3 RID: 419
		// (get) Token: 0x0600089A RID: 2202 RVA: 0x000053A0 File Offset: 0x000035A0
		[Token(Token = "0x170001A3")]
		public int AssignedEditPositionCount
		{
			[Token(Token = "0x600089A")]
			[Address(RVA = "0x471180", Offset = "0x470180", VA = "0x180471180")]
			get
			{
				return 0;
			}
		}

		/// <summary>Gets the number of editable character positions in the input mask that have not yet been assigned an input value.</summary>
		/// <returns>An <see cref="T:System.Int32" /> containing the number of editable character positions that not yet been assigned a character value.</returns>
		// Token: 0x170001A4 RID: 420
		// (get) Token: 0x0600089B RID: 2203 RVA: 0x000053B8 File Offset: 0x000035B8
		[Token(Token = "0x170001A4")]
		public int AvailableEditPositionCount
		{
			[Token(Token = "0x600089B")]
			[Address(RVA = "0xC63FC0", Offset = "0xC62FC0", VA = "0x180C63FC0")]
			get
			{
				return 0;
			}
		}

		/// <summary>Creates a copy of the current <see cref="T:System.ComponentModel.MaskedTextProvider" />.</summary>
		/// <returns>The <see cref="T:System.ComponentModel.MaskedTextProvider" /> object this method creates, cast as an object.</returns>
		// Token: 0x0600089C RID: 2204 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600089C")]
		[Address(RVA = "0xC5E9E0", Offset = "0xC5D9E0", VA = "0x180C5E9E0", Slot = "4")]
		public object Clone()
		{
			return null;
		}

		/// <summary>Gets the culture that determines the value of the localizable separators and placeholders in the input mask.</summary>
		/// <returns>A <see cref="T:System.Globalization.CultureInfo" /> containing the culture information associated with the input mask.</returns>
		// Token: 0x170001A5 RID: 421
		// (get) Token: 0x0600089D RID: 2205 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x170001A5")]
		public CultureInfo Culture
		{
			[Token(Token = "0x600089D")]
			[Address(RVA = "0x4157B0", Offset = "0x4147B0", VA = "0x1804157B0")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets the default password character used obscure user input.</summary>
		/// <returns>A <see cref="T:System.Char" /> that represents the default password character.</returns>
		// Token: 0x170001A6 RID: 422
		// (get) Token: 0x0600089E RID: 2206 RVA: 0x000053D0 File Offset: 0x000035D0
		[Token(Token = "0x170001A6")]
		public static char DefaultPasswordChar
		{
			[Token(Token = "0x600089E")]
			[Address(RVA = "0xC45B10", Offset = "0xC44B10", VA = "0x180C45B10")]
			get
			{
				return '\0';
			}
		}

		/// <summary>Gets the number of editable positions in the formatted string.</summary>
		/// <returns>An <see cref="T:System.Int32" /> containing the number of editable positions in the formatted string.</returns>
		// Token: 0x170001A7 RID: 423
		// (get) Token: 0x0600089F RID: 2207 RVA: 0x000053E8 File Offset: 0x000035E8
		[Token(Token = "0x170001A7")]
		public int EditPositionCount
		{
			[Token(Token = "0x600089F")]
			[Address(RVA = "0xC63FD0", Offset = "0xC62FD0", VA = "0x180C63FD0")]
			get
			{
				return 0;
			}
		}

		/// <summary>Gets a newly created enumerator for the editable positions in the formatted string.</summary>
		/// <returns>An <see cref="T:System.Collections.IEnumerator" /> that supports enumeration over the editable positions in the formatted string.</returns>
		// Token: 0x170001A8 RID: 424
		// (get) Token: 0x060008A0 RID: 2208 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x170001A8")]
		public IEnumerator EditPositions
		{
			[Token(Token = "0x60008A0")]
			[Address(RVA = "0xC63FE0", Offset = "0xC62FE0", VA = "0x180C63FE0")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets or sets a value that indicates whether literal characters in the input mask should be included in the formatted string.</summary>
		/// <returns>
		///   <see langword="true" /> if literals are included; otherwise, <see langword="false" />. The default is <see langword="true" />.</returns>
		// Token: 0x170001A9 RID: 425
		// (get) Token: 0x060008A1 RID: 2209 RVA: 0x00005400 File Offset: 0x00003600
		// (set) Token: 0x060008A2 RID: 2210 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001A9")]
		public bool IncludeLiterals
		{
			[Token(Token = "0x60008A1")]
			[Address(RVA = "0xC64170", Offset = "0xC63170", VA = "0x180C64170")]
			get
			{
				return default(bool);
			}
			[Token(Token = "0x60008A2")]
			[Address(RVA = "0xC64540", Offset = "0xC63540", VA = "0x180C64540")]
			set
			{
			}
		}

		/// <summary>Gets or sets a value indicating whether <see cref="P:System.Windows.Forms.MaskedTextBox.PromptChar" /> is used to represent the absence of user input when displaying the formatted string.</summary>
		/// <returns>
		///   <see langword="true" /> if the prompt character is used to represent the positions where no user input was provided; otherwise, <see langword="false" />. The default is <see langword="true" />.</returns>
		// Token: 0x170001AA RID: 426
		// (get) Token: 0x060008A3 RID: 2211 RVA: 0x00005418 File Offset: 0x00003618
		// (set) Token: 0x060008A4 RID: 2212 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001AA")]
		public bool IncludePrompt
		{
			[Token(Token = "0x60008A3")]
			[Address(RVA = "0xC641E0", Offset = "0xC631E0", VA = "0x180C641E0")]
			get
			{
				return default(bool);
			}
			[Token(Token = "0x60008A4")]
			[Address(RVA = "0xC645C0", Offset = "0xC635C0", VA = "0x180C645C0")]
			set
			{
			}
		}

		/// <summary>Gets a value indicating whether the mask accepts characters outside of the ASCII character set.</summary>
		/// <returns>
		///   <see langword="true" /> if only ASCII is accepted; <see langword="false" /> if <see cref="T:System.ComponentModel.MaskedTextProvider" /> can accept any arbitrary Unicode character. The default is <see langword="false" />.</returns>
		// Token: 0x170001AB RID: 427
		// (get) Token: 0x060008A5 RID: 2213 RVA: 0x00005430 File Offset: 0x00003630
		[Token(Token = "0x170001AB")]
		public bool AsciiOnly
		{
			[Token(Token = "0x60008A5")]
			[Address(RVA = "0xC63F50", Offset = "0xC62F50", VA = "0x180C63F50")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets or sets a value that determines whether password protection should be applied to the formatted string.</summary>
		/// <returns>
		///   <see langword="true" /> if the input string is to be treated as a password string; otherwise, <see langword="false" />. The default is <see langword="false" />.</returns>
		// Token: 0x170001AC RID: 428
		// (get) Token: 0x060008A6 RID: 2214 RVA: 0x00005448 File Offset: 0x00003648
		// (set) Token: 0x060008A7 RID: 2215 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001AC")]
		public bool IsPassword
		{
			[Token(Token = "0x60008A6")]
			[Address(RVA = "0xC64250", Offset = "0xC63250", VA = "0x180C64250")]
			get
			{
				return default(bool);
			}
			[Token(Token = "0x60008A7")]
			[Address(RVA = "0xC64640", Offset = "0xC63640", VA = "0x180C64640")]
			set
			{
			}
		}

		/// <summary>Gets the upper bound of the range of invalid indexes.</summary>
		/// <returns>A value representing the largest invalid index, as determined by the provider implementation. For example, if the lowest valid index is 0, this property will return -1.</returns>
		// Token: 0x170001AD RID: 429
		// (get) Token: 0x060008A8 RID: 2216 RVA: 0x00005460 File Offset: 0x00003660
		[Token(Token = "0x170001AD")]
		public static int InvalidIndex
		{
			[Token(Token = "0x60008A8")]
			[Address(RVA = "0x716A60", Offset = "0x715A60", VA = "0x180716A60")]
			get
			{
				return 0;
			}
		}

		/// <summary>Gets the index in the mask of the rightmost input character that has been assigned to the mask.</summary>
		/// <returns>If at least one input character has been assigned to the mask, an <see cref="T:System.Int32" /> containing the index of rightmost assigned position; otherwise, if no position has been assigned, <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x170001AE RID: 430
		// (get) Token: 0x060008A9 RID: 2217 RVA: 0x00005478 File Offset: 0x00003678
		[Token(Token = "0x170001AE")]
		public int LastAssignedPosition
		{
			[Token(Token = "0x60008A9")]
			[Address(RVA = "0xC64340", Offset = "0xC63340", VA = "0x180C64340")]
			get
			{
				return 0;
			}
		}

		/// <summary>Gets the length of the mask, absent any mask modifier characters.</summary>
		/// <returns>An <see cref="T:System.Int32" /> containing the number of positions in the mask, excluding characters that modify mask input.</returns>
		// Token: 0x170001AF RID: 431
		// (get) Token: 0x060008AA RID: 2218 RVA: 0x00005490 File Offset: 0x00003690
		[Token(Token = "0x170001AF")]
		public int Length
		{
			[Token(Token = "0x60008AA")]
			[Address(RVA = "0xC64390", Offset = "0xC63390", VA = "0x180C64390")]
			get
			{
				return 0;
			}
		}

		/// <summary>Gets the input mask.</summary>
		/// <returns>A <see cref="T:System.String" /> containing the full mask.</returns>
		// Token: 0x170001B0 RID: 432
		// (get) Token: 0x060008AB RID: 2219 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x170001B0")]
		public string Mask
		{
			[Token(Token = "0x60008AB")]
			[Address(RVA = "0x41CEF0", Offset = "0x41BEF0", VA = "0x18041CEF0")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets a value indicating whether all required inputs have been entered into the formatted string.</summary>
		/// <returns>
		///   <see langword="true" /> if all required input has been entered into the mask; otherwise, <see langword="false" />.</returns>
		// Token: 0x170001B1 RID: 433
		// (get) Token: 0x060008AC RID: 2220 RVA: 0x000054A8 File Offset: 0x000036A8
		[Token(Token = "0x170001B1")]
		public bool MaskCompleted
		{
			[Token(Token = "0x60008AC")]
			[Address(RVA = "0xC643B0", Offset = "0xC633B0", VA = "0x180C643B0")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets a value indicating whether all required and optional inputs have been entered into the formatted string.</summary>
		/// <returns>
		///   <see langword="true" /> if all required and optional inputs have been entered; otherwise, <see langword="false" />.</returns>
		// Token: 0x170001B2 RID: 434
		// (get) Token: 0x060008AD RID: 2221 RVA: 0x000054C0 File Offset: 0x000036C0
		[Token(Token = "0x170001B2")]
		public bool MaskFull
		{
			[Token(Token = "0x60008AD")]
			[Address(RVA = "0xC643C0", Offset = "0xC633C0", VA = "0x180C643C0")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets or sets the character to be substituted for the actual input characters.</summary>
		/// <returns>The <see cref="T:System.Char" /> value used as the password character.</returns>
		/// <exception cref="T:System.InvalidOperationException">The password character specified when setting this property is the same as the current prompt character, <see cref="P:System.ComponentModel.MaskedTextProvider.PromptChar" />. The two are required to be different.</exception>
		/// <exception cref="T:System.ArgumentException">The character specified when setting this property is not a valid password character, as determined by the <see cref="M:System.ComponentModel.MaskedTextProvider.IsValidPasswordChar(System.Char)" /> method.</exception>
		// Token: 0x170001B3 RID: 435
		// (get) Token: 0x060008AE RID: 2222 RVA: 0x000054D8 File Offset: 0x000036D8
		// (set) Token: 0x060008AF RID: 2223 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001B3")]
		public char PasswordChar
		{
			[Token(Token = "0x60008AE")]
			[Address(RVA = "0xC643D0", Offset = "0xC633D0", VA = "0x180C643D0")]
			get
			{
				return '\0';
			}
			[Token(Token = "0x60008AF")]
			[Address(RVA = "0xC646C0", Offset = "0xC636C0", VA = "0x180C646C0")]
			set
			{
			}
		}

		/// <summary>Gets or sets the character used to represent the absence of user input for all available edit positions.</summary>
		/// <returns>The character used to prompt the user for input. The default is an underscore (_).</returns>
		/// <exception cref="T:System.InvalidOperationException">The prompt character specified when setting this property is the same as the current password character, <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" />. The two are required to be different.</exception>
		/// <exception cref="T:System.ArgumentException">The character specified when setting this property is not a valid password character, as determined by the <see cref="M:System.ComponentModel.MaskedTextProvider.IsValidPasswordChar(System.Char)" /> method.</exception>
		// Token: 0x170001B4 RID: 436
		// (get) Token: 0x060008B0 RID: 2224 RVA: 0x000054F0 File Offset: 0x000036F0
		// (set) Token: 0x060008B1 RID: 2225 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001B4")]
		public char PromptChar
		{
			[Token(Token = "0x60008B0")]
			[Address(RVA = "0xC643E0", Offset = "0xC633E0", VA = "0x180C643E0")]
			get
			{
				return '\0';
			}
			[Token(Token = "0x60008B1")]
			[Address(RVA = "0xC64800", Offset = "0xC63800", VA = "0x180C64800")]
			set
			{
			}
		}

		/// <summary>Gets or sets a value that determines how an input character that matches the prompt character should be handled.</summary>
		/// <returns>
		///   <see langword="true" /> if the prompt character entered as input causes the current editable position in the mask to be reset; otherwise, <see langword="false" /> to indicate that the prompt character is to be processed as a normal input character. The default is <see langword="true" />.</returns>
		// Token: 0x170001B5 RID: 437
		// (get) Token: 0x060008B2 RID: 2226 RVA: 0x00005508 File Offset: 0x00003708
		// (set) Token: 0x060008B3 RID: 2227 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001B5")]
		public bool ResetOnPrompt
		{
			[Token(Token = "0x60008B2")]
			[Address(RVA = "0xC643F0", Offset = "0xC633F0", VA = "0x180C643F0")]
			get
			{
				return default(bool);
			}
			[Token(Token = "0x60008B3")]
			[Address(RVA = "0xC649A0", Offset = "0xC639A0", VA = "0x180C649A0")]
			set
			{
			}
		}

		/// <summary>Gets or sets a value that determines how a space input character should be handled.</summary>
		/// <returns>
		///   <see langword="true" /> if the space input character causes the current editable position in the mask to be reset; otherwise, <see langword="false" /> to indicate that it is to be processed as a normal input character. The default is <see langword="true" />.</returns>
		// Token: 0x170001B6 RID: 438
		// (get) Token: 0x060008B4 RID: 2228 RVA: 0x00005520 File Offset: 0x00003720
		// (set) Token: 0x060008B5 RID: 2229 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001B6")]
		public bool ResetOnSpace
		{
			[Token(Token = "0x60008B4")]
			[Address(RVA = "0xC64460", Offset = "0xC63460", VA = "0x180C64460")]
			get
			{
				return default(bool);
			}
			[Token(Token = "0x60008B5")]
			[Address(RVA = "0xC64A20", Offset = "0xC63A20", VA = "0x180C64A20")]
			set
			{
			}
		}

		/// <summary>Gets or sets a value indicating whether literal character positions in the mask can be overwritten by their same values.</summary>
		/// <returns>
		///   <see langword="true" /> to allow literals to be added back; otherwise, <see langword="false" /> to not allow the user to overwrite literal characters. The default is <see langword="true" />.</returns>
		// Token: 0x170001B7 RID: 439
		// (get) Token: 0x060008B6 RID: 2230 RVA: 0x00005538 File Offset: 0x00003738
		// (set) Token: 0x060008B7 RID: 2231 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x170001B7")]
		public bool SkipLiterals
		{
			[Token(Token = "0x60008B6")]
			[Address(RVA = "0xC644D0", Offset = "0xC634D0", VA = "0x180C644D0")]
			get
			{
				return default(bool);
			}
			[Token(Token = "0x60008B7")]
			[Address(RVA = "0xC64AA0", Offset = "0xC63AA0", VA = "0x180C64AA0")]
			set
			{
			}
		}

		/// <summary>Gets the element at the specified position in the formatted string.</summary>
		/// <param name="index">A zero-based index of the element to retrieve.</param>
		/// <returns>The <see cref="T:System.Char" /> at the specified position in the formatted string.</returns>
		/// <exception cref="T:System.IndexOutOfRangeException">
		///   <paramref name="index" /> is less than zero or greater than or equal to the <see cref="P:System.ComponentModel.MaskedTextProvider.Length" /> of the mask.</exception>
		// Token: 0x170001B8 RID: 440
		[Token(Token = "0x170001B8")]
		public char this[int index]
		{
			[Token(Token = "0x60008B8")]
			[Address(RVA = "0xC64260", Offset = "0xC63260", VA = "0x180C64260")]
			get
			{
				return '\0';
			}
		}

		/// <summary>Adds the specified input character to the end of the formatted string.</summary>
		/// <param name="input">A <see cref="T:System.Char" /> value to be appended to the formatted string.</param>
		/// <returns>
		///   <see langword="true" /> if the input character was added successfully; otherwise <see langword="false" />.</returns>
		// Token: 0x060008B9 RID: 2233 RVA: 0x00005568 File Offset: 0x00003768
		[Token(Token = "0x60008B9")]
		[Address(RVA = "0xC5E670", Offset = "0xC5D670", VA = "0x180C5E670")]
		public bool Add(char input)
		{
			return default(bool);
		}

		/// <summary>Adds the specified input character to the end of the formatted string, and then outputs position and descriptive information.</summary>
		/// <param name="input">A <see cref="T:System.Char" /> value to be appended to the formatted string.</param>
		/// <param name="testPosition">The zero-based position in the formatted string where the attempt was made to add the character. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the input character was added successfully; otherwise <see langword="false" />.</returns>
		// Token: 0x060008BA RID: 2234 RVA: 0x00005580 File Offset: 0x00003780
		[Token(Token = "0x60008BA")]
		[Address(RVA = "0xC5E770", Offset = "0xC5D770", VA = "0x180C5E770")]
		public bool Add(char input, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Adds the characters in the specified input string to the end of the formatted string.</summary>
		/// <param name="input">A <see cref="T:System.String" /> containing character values to be appended to the formatted string.</param>
		/// <returns>
		///   <see langword="true" /> if all the characters from the input string were added successfully; otherwise <see langword="false" /> to indicate that no characters were added.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
		// Token: 0x060008BB RID: 2235 RVA: 0x00005598 File Offset: 0x00003798
		[Token(Token = "0x60008BB")]
		[Address(RVA = "0xC5E420", Offset = "0xC5D420", VA = "0x180C5E420")]
		public bool Add(string input)
		{
			return default(bool);
		}

		/// <summary>Adds the characters in the specified input string to the end of the formatted string, and then outputs position and descriptive information.</summary>
		/// <param name="input">A <see cref="T:System.String" /> containing character values to be appended to the formatted string.</param>
		/// <param name="testPosition">The zero-based position in the formatted string where the attempt was made to add the character. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if all the characters from the input string were added successfully; otherwise <see langword="false" /> to indicate that no characters were added.</returns>
		// Token: 0x060008BC RID: 2236 RVA: 0x000055B0 File Offset: 0x000037B0
		[Token(Token = "0x60008BC")]
		[Address(RVA = "0xC5E540", Offset = "0xC5D540", VA = "0x180C5E540")]
		public bool Add(string input, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Clears all the editable input characters from the formatted string, replacing them with prompt characters.</summary>
		// Token: 0x060008BD RID: 2237 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x60008BD")]
		[Address(RVA = "0xC5E8B0", Offset = "0xC5D8B0", VA = "0x180C5E8B0")]
		public void Clear()
		{
		}

		/// <summary>Clears all the editable input characters from the formatted string, replacing them with prompt characters, and then outputs descriptive information.</summary>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
		// Token: 0x060008BE RID: 2238 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x60008BE")]
		[Address(RVA = "0xC5E8D0", Offset = "0xC5D8D0", VA = "0x180C5E8D0")]
		public void Clear(out MaskedTextResultHint resultHint)
		{
		}

		/// <summary>Returns the position of the first assigned editable position after the specified position using the specified search direction.</summary>
		/// <param name="position">The zero-based position in the formatted string to start the search.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first assigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008BF RID: 2239 RVA: 0x000055C8 File Offset: 0x000037C8
		[Token(Token = "0x60008BF")]
		[Address(RVA = "0xC5F3F0", Offset = "0xC5E3F0", VA = "0x180C5F3F0")]
		public int FindAssignedEditPositionFrom(int position, bool direction)
		{
			return 0;
		}

		/// <summary>Returns the position of the first assigned editable position between the specified positions using the specified search direction.</summary>
		/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
		/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first assigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008C0 RID: 2240 RVA: 0x000055E0 File Offset: 0x000037E0
		[Token(Token = "0x60008C0")]
		[Address(RVA = "0xC5F470", Offset = "0xC5E470", VA = "0x180C5F470")]
		public int FindAssignedEditPositionInRange(int startPosition, int endPosition, bool direction)
		{
			return 0;
		}

		/// <summary>Returns the position of the first editable position after the specified position using the specified search direction.</summary>
		/// <param name="position">The zero-based position in the formatted string to start the search.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008C1 RID: 2241 RVA: 0x000055F8 File Offset: 0x000037F8
		[Token(Token = "0x60008C1")]
		[Address(RVA = "0xC5F590", Offset = "0xC5E590", VA = "0x180C5F590")]
		public int FindEditPositionFrom(int position, bool direction)
		{
			return 0;
		}

		/// <summary>Returns the position of the first editable position between the specified positions using the specified search direction.</summary>
		/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
		/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008C2 RID: 2242 RVA: 0x00005610 File Offset: 0x00003810
		[Token(Token = "0x60008C2")]
		[Address(RVA = "0xC5F730", Offset = "0xC5E730", VA = "0x180C5F730")]
		public int FindEditPositionInRange(int startPosition, int endPosition, bool direction)
		{
			return 0;
		}

		// Token: 0x060008C3 RID: 2243 RVA: 0x00005628 File Offset: 0x00003828
		[Token(Token = "0x60008C3")]
		[Address(RVA = "0xC5F600", Offset = "0xC5E600", VA = "0x180C5F600")]
		private int FindEditPositionInRange(int startPosition, int endPosition, bool direction, byte assignedStatus)
		{
			return 0;
		}

		/// <summary>Returns the position of the first non-editable position after the specified position using the specified search direction.</summary>
		/// <param name="position">The zero-based position in the formatted string to start the search.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first literal position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008C4 RID: 2244 RVA: 0x00005640 File Offset: 0x00003840
		[Token(Token = "0x60008C4")]
		[Address(RVA = "0xC5F750", Offset = "0xC5E750", VA = "0x180C5F750")]
		public int FindNonEditPositionFrom(int position, bool direction)
		{
			return 0;
		}

		/// <summary>Returns the position of the first non-editable position between the specified positions using the specified search direction.</summary>
		/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
		/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first literal position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008C5 RID: 2245 RVA: 0x00005658 File Offset: 0x00003858
		[Token(Token = "0x60008C5")]
		[Address(RVA = "0xC5F7C0", Offset = "0xC5E7C0", VA = "0x180C5F7C0")]
		public int FindNonEditPositionInRange(int startPosition, int endPosition, bool direction)
		{
			return 0;
		}

		// Token: 0x060008C6 RID: 2246 RVA: 0x00005670 File Offset: 0x00003870
		[Token(Token = "0x60008C6")]
		[Address(RVA = "0xC5F7E0", Offset = "0xC5E7E0", VA = "0x180C5F7E0")]
		private int FindPositionInRange(int startPosition, int endPosition, bool direction, MaskedTextProvider.CharType charTypeFlags)
		{
			return 0;
		}

		/// <summary>Returns the position of the first unassigned editable position after the specified position using the specified search direction.</summary>
		/// <param name="position">The zero-based position in the formatted string to start the search.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first unassigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008C7 RID: 2247 RVA: 0x00005688 File Offset: 0x00003888
		[Token(Token = "0x60008C7")]
		[Address(RVA = "0xC5F8D0", Offset = "0xC5E8D0", VA = "0x180C5F8D0")]
		public int FindUnassignedEditPositionFrom(int position, bool direction)
		{
			return 0;
		}

		/// <summary>Returns the position of the first unassigned editable position between the specified positions using the specified search direction.</summary>
		/// <param name="startPosition">The zero-based position in the formatted string where the search starts.</param>
		/// <param name="endPosition">The zero-based position in the formatted string where the search ends.</param>
		/// <param name="direction">A <see cref="T:System.Boolean" /> indicating the search direction; either <see langword="true" /> to search forward or <see langword="false" /> to search backward.</param>
		/// <returns>If successful, an <see cref="T:System.Int32" /> representing the zero-based position of the first unassigned editable position encountered; otherwise <see cref="P:System.ComponentModel.MaskedTextProvider.InvalidIndex" />.</returns>
		// Token: 0x060008C8 RID: 2248 RVA: 0x000056A0 File Offset: 0x000038A0
		[Token(Token = "0x60008C8")]
		[Address(RVA = "0xC5FA00", Offset = "0xC5EA00", VA = "0x180C5FA00")]
		public int FindUnassignedEditPositionInRange(int startPosition, int endPosition, bool direction)
		{
			return 0;
		}

		/// <summary>Determines whether the specified <see cref="T:System.ComponentModel.MaskedTextResultHint" /> denotes success or failure.</summary>
		/// <param name="hint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> value typically obtained as an output parameter from a previous operation.</param>
		/// <returns>
		///   <see langword="true" /> if the specified <see cref="T:System.ComponentModel.MaskedTextResultHint" /> value represents a success; otherwise, <see langword="false" /> if it represents failure.</returns>
		// Token: 0x060008C9 RID: 2249 RVA: 0x000056B8 File Offset: 0x000038B8
		[Token(Token = "0x60008C9")]
		[Address(RVA = "0xC5FB20", Offset = "0xC5EB20", VA = "0x180C5FB20")]
		public static bool GetOperationResultFromHint(MaskedTextResultHint hint)
		{
			return default(bool);
		}

		/// <summary>Inserts the specified character at the specified position within the formatted string.</summary>
		/// <param name="input">The <see cref="T:System.Char" /> to be inserted.</param>
		/// <param name="position">The zero-based position in the formatted string to insert the character.</param>
		/// <returns>
		///   <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008CA RID: 2250 RVA: 0x000056D0 File Offset: 0x000038D0
		[Token(Token = "0x60008CA")]
		[Address(RVA = "0xC60590", Offset = "0xC5F590", VA = "0x180C60590")]
		public bool InsertAt(char input, int position)
		{
			return default(bool);
		}

		/// <summary>Inserts the specified character at the specified position within the formatted string, returning the last insertion position and the status of the operation.</summary>
		/// <param name="input">The <see cref="T:System.Char" /> to be inserted.</param>
		/// <param name="position">The zero-based position in the formatted string to insert the character.</param>
		/// <param name="testPosition">If the method is successful, the last position where a character was inserted; otherwise, the first position where the insertion failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the insertion operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008CB RID: 2251 RVA: 0x000056E8 File Offset: 0x000038E8
		[Token(Token = "0x60008CB")]
		[Address(RVA = "0xC60530", Offset = "0xC5F530", VA = "0x180C60530")]
		public bool InsertAt(char input, int position, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Inserts the specified string at a specified position within the formatted string.</summary>
		/// <param name="input">The <see cref="T:System.String" /> to be inserted.</param>
		/// <param name="position">The zero-based position in the formatted string to insert the input string.</param>
		/// <returns>
		///   <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
		// Token: 0x060008CC RID: 2252 RVA: 0x00005700 File Offset: 0x00003900
		[Token(Token = "0x60008CC")]
		[Address(RVA = "0xC60440", Offset = "0xC5F440", VA = "0x180C60440")]
		public bool InsertAt(string input, int position)
		{
			return default(bool);
		}

		/// <summary>Inserts the specified string at a specified position within the formatted string, returning the last insertion position and the status of the operation.</summary>
		/// <param name="input">The <see cref="T:System.String" /> to be inserted.</param>
		/// <param name="position">The zero-based position in the formatted string to insert the input string.</param>
		/// <param name="testPosition">If the method is successful, the last position where a character was inserted; otherwise, the first position where the insertion failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the insertion operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the insertion was successful; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
		// Token: 0x060008CD RID: 2253 RVA: 0x00005718 File Offset: 0x00003918
		[Token(Token = "0x60008CD")]
		[Address(RVA = "0xC60350", Offset = "0xC5F350", VA = "0x180C60350")]
		public bool InsertAt(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x060008CE RID: 2254 RVA: 0x00005730 File Offset: 0x00003930
		[Token(Token = "0x60008CE")]
		[Address(RVA = "0xC5FF50", Offset = "0xC5EF50", VA = "0x180C5FF50")]
		private bool InsertAtInt(string input, int position, out int testPosition, out MaskedTextResultHint resultHint, bool testOnly)
		{
			return default(bool);
		}

		// Token: 0x060008CF RID: 2255 RVA: 0x00005748 File Offset: 0x00003948
		[Token(Token = "0x60008CF")]
		[Address(RVA = "0xC60790", Offset = "0xC5F790", VA = "0x180C60790")]
		private static bool IsAscii(char c)
		{
			return default(bool);
		}

		// Token: 0x060008D0 RID: 2256 RVA: 0x00005760 File Offset: 0x00003960
		[Token(Token = "0x60008D0")]
		[Address(RVA = "0xC606B0", Offset = "0xC5F6B0", VA = "0x180C606B0")]
		private static bool IsAciiAlphanumeric(char c)
		{
			return default(bool);
		}

		// Token: 0x060008D1 RID: 2257 RVA: 0x00005778 File Offset: 0x00003978
		[Token(Token = "0x60008D1")]
		[Address(RVA = "0xC606E0", Offset = "0xC5F6E0", VA = "0x180C606E0")]
		private static bool IsAlphanumeric(char c)
		{
			return default(bool);
		}

		// Token: 0x060008D2 RID: 2258 RVA: 0x00005790 File Offset: 0x00003990
		[Token(Token = "0x60008D2")]
		[Address(RVA = "0xC60770", Offset = "0xC5F770", VA = "0x180C60770")]
		private static bool IsAsciiLetter(char c)
		{
			return default(bool);
		}

		/// <summary>Determines whether the specified position is available for assignment.</summary>
		/// <param name="position">The zero-based position in the mask to test.</param>
		/// <returns>
		///   <see langword="true" /> if the specified position in the formatted string is editable and has not been assigned to yet; otherwise <see langword="false" />.</returns>
		// Token: 0x060008D3 RID: 2259 RVA: 0x000057A8 File Offset: 0x000039A8
		[Token(Token = "0x60008D3")]
		[Address(RVA = "0xC607B0", Offset = "0xC5F7B0", VA = "0x180C607B0")]
		public bool IsAvailablePosition(int position)
		{
			return default(bool);
		}

		/// <summary>Determines whether the specified position is editable.</summary>
		/// <param name="position">The zero-based position in the mask to test.</param>
		/// <returns>
		///   <see langword="true" /> if the specified position in the formatted string is editable; otherwise <see langword="false" />.</returns>
		// Token: 0x060008D4 RID: 2260 RVA: 0x000057C0 File Offset: 0x000039C0
		[Token(Token = "0x60008D4")]
		[Address(RVA = "0xC608A0", Offset = "0xC5F8A0", VA = "0x180C608A0")]
		public bool IsEditPosition(int position)
		{
			return default(bool);
		}

		// Token: 0x060008D5 RID: 2261 RVA: 0x000057D8 File Offset: 0x000039D8
		[Token(Token = "0x60008D5")]
		[Address(RVA = "0xC60870", Offset = "0xC5F870", VA = "0x180C60870")]
		private static bool IsEditPosition(MaskedTextProvider.CharDescriptor charDescriptor)
		{
			return default(bool);
		}

		// Token: 0x060008D6 RID: 2262 RVA: 0x000057F0 File Offset: 0x000039F0
		[Token(Token = "0x60008D6")]
		[Address(RVA = "0xC60960", Offset = "0xC5F960", VA = "0x180C60960")]
		private static bool IsLiteralPosition(MaskedTextProvider.CharDescriptor charDescriptor)
		{
			return default(bool);
		}

		// Token: 0x060008D7 RID: 2263 RVA: 0x00005808 File Offset: 0x00003A08
		[Token(Token = "0x60008D7")]
		[Address(RVA = "0xC60990", Offset = "0xC5F990", VA = "0x180C60990")]
		private static bool IsPrintableChar(char c)
		{
			return default(bool);
		}

		/// <summary>Determines whether the specified character is a valid input character.</summary>
		/// <param name="c">The <see cref="T:System.Char" /> value to test.</param>
		/// <returns>
		///   <see langword="true" /> if the specified character contains a valid input value; otherwise <see langword="false" />.</returns>
		// Token: 0x060008D8 RID: 2264 RVA: 0x00005820 File Offset: 0x00003A20
		[Token(Token = "0x60008D8")]
		[Address(RVA = "0xC60A50", Offset = "0xC5FA50", VA = "0x180C60A50")]
		public static bool IsValidInputChar(char c)
		{
			return default(bool);
		}

		/// <summary>Determines whether the specified character is a valid mask character.</summary>
		/// <param name="c">The <see cref="T:System.Char" /> value to test.</param>
		/// <returns>
		///   <see langword="true" /> if the specified character contains a valid mask value; otherwise <see langword="false" />.</returns>
		// Token: 0x060008D9 RID: 2265 RVA: 0x00005838 File Offset: 0x00003A38
		[Token(Token = "0x60008D9")]
		[Address(RVA = "0xC60AB0", Offset = "0xC5FAB0", VA = "0x180C60AB0")]
		public static bool IsValidMaskChar(char c)
		{
			return default(bool);
		}

		/// <summary>Determines whether the specified character is a valid password character.</summary>
		/// <param name="c">The <see cref="T:System.Char" /> value to test.</param>
		/// <returns>
		///   <see langword="true" /> if the specified character contains a valid password value; otherwise <see langword="false" />.</returns>
		// Token: 0x060008DA RID: 2266 RVA: 0x00005850 File Offset: 0x00003A50
		[Token(Token = "0x60008DA")]
		[Address(RVA = "0xC60B10", Offset = "0xC5FB10", VA = "0x180C60B10")]
		public static bool IsValidPasswordChar(char c)
		{
			return default(bool);
		}

		/// <summary>Removes the last assigned character from the formatted string.</summary>
		/// <returns>
		///   <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008DB RID: 2267 RVA: 0x00005868 File Offset: 0x00003A68
		[Token(Token = "0x60008DB")]
		[Address(RVA = "0xC611B0", Offset = "0xC601B0", VA = "0x180C611B0")]
		public bool Remove()
		{
			return default(bool);
		}

		/// <summary>Removes the last assigned character from the formatted string, and then outputs the removal position and descriptive information.</summary>
		/// <param name="testPosition">The zero-based position in the formatted string where the character was actually removed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008DC RID: 2268 RVA: 0x00005880 File Offset: 0x00003A80
		[Token(Token = "0x60008DC")]
		[Address(RVA = "0xC61110", Offset = "0xC60110", VA = "0x180C61110")]
		public bool Remove(out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Removes the assigned character at the specified position from the formatted string.</summary>
		/// <param name="position">The zero-based position of the assigned character to remove.</param>
		/// <returns>
		///   <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008DD RID: 2269 RVA: 0x00005898 File Offset: 0x00003A98
		[Token(Token = "0x60008DD")]
		[Address(RVA = "0xC61090", Offset = "0xC60090", VA = "0x180C61090")]
		public bool RemoveAt(int position)
		{
			return default(bool);
		}

		/// <summary>Removes the assigned characters between the specified positions from the formatted string.</summary>
		/// <param name="startPosition">The zero-based index of the first assigned character to remove.</param>
		/// <param name="endPosition">The zero-based index of the last assigned character to remove.</param>
		/// <returns>
		///   <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008DE RID: 2270 RVA: 0x000058B0 File Offset: 0x00003AB0
		[Token(Token = "0x60008DE")]
		[Address(RVA = "0xC60F50", Offset = "0xC5FF50", VA = "0x180C60F50")]
		public bool RemoveAt(int startPosition, int endPosition)
		{
			return default(bool);
		}

		/// <summary>Removes the assigned characters between the specified positions from the formatted string, and then outputs the removal position and descriptive information.</summary>
		/// <param name="startPosition">The zero-based index of the first assigned character to remove.</param>
		/// <param name="endPosition">The zero-based index of the last assigned character to remove.</param>
		/// <param name="testPosition">If successful, the zero-based position in the formatted string of where the characters were actually removed; otherwise, the first position where the operation failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the character was successfully removed; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008DF RID: 2271 RVA: 0x000058C8 File Offset: 0x00003AC8
		[Token(Token = "0x60008DF")]
		[Address(RVA = "0xC60FF0", Offset = "0xC5FFF0", VA = "0x180C60FF0")]
		public bool RemoveAt(int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x060008E0 RID: 2272 RVA: 0x000058E0 File Offset: 0x00003AE0
		[Token(Token = "0x60008E0")]
		[Address(RVA = "0xC60B80", Offset = "0xC5FB80", VA = "0x180C60B80")]
		private bool RemoveAtInt(int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint, bool testOnly)
		{
			return default(bool);
		}

		/// <summary>Replaces a single character at or beyond the specified position with the specified character value.</summary>
		/// <param name="input">The <see cref="T:System.Char" /> value that replaces the existing value.</param>
		/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
		/// <returns>
		///   <see langword="true" /> if the character was successfully replaced; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008E1 RID: 2273 RVA: 0x000058F8 File Offset: 0x00003AF8
		[Token(Token = "0x60008E1")]
		[Address(RVA = "0xC61320", Offset = "0xC60320", VA = "0x180C61320")]
		public bool Replace(char input, int position)
		{
			return default(bool);
		}

		/// <summary>Replaces a single character at or beyond the specified position with the specified character value, and then outputs the removal position and descriptive information.</summary>
		/// <param name="input">The <see cref="T:System.Char" /> value that replaces the existing value.</param>
		/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
		/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the character was successfully replaced; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008E2 RID: 2274 RVA: 0x00005910 File Offset: 0x00003B10
		[Token(Token = "0x60008E2")]
		[Address(RVA = "0xC61210", Offset = "0xC60210", VA = "0x180C61210")]
		public bool Replace(char input, int position, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Replaces a single character between the specified starting and ending positions with the specified character value, and then outputs the removal position and descriptive information.</summary>
		/// <param name="input">The <see cref="T:System.Char" /> value that replaces the existing value.</param>
		/// <param name="startPosition">The zero-based position in the formatted string where the replacement starts.</param>
		/// <param name="endPosition">The zero-based position in the formatted string where the replacement ends.</param>
		/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the character was successfully replaced; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008E3 RID: 2275 RVA: 0x00005928 File Offset: 0x00003B28
		[Token(Token = "0x60008E3")]
		[Address(RVA = "0xC619A0", Offset = "0xC609A0", VA = "0x180C619A0")]
		public bool Replace(char input, int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Replaces a range of editable characters starting at the specified position with the specified string.</summary>
		/// <param name="input">The <see cref="T:System.String" /> value used to replace the existing editable characters.</param>
		/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
		/// <returns>
		///   <see langword="true" /> if all the characters were successfully replaced; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
		// Token: 0x060008E4 RID: 2276 RVA: 0x00005940 File Offset: 0x00003B40
		[Token(Token = "0x60008E4")]
		[Address(RVA = "0xC618B0", Offset = "0xC608B0", VA = "0x180C618B0")]
		public bool Replace(string input, int position)
		{
			return default(bool);
		}

		/// <summary>Replaces a range of editable characters starting at the specified position with the specified string, and then outputs the removal position and descriptive information.</summary>
		/// <param name="input">The <see cref="T:System.String" /> value used to replace the existing editable characters.</param>
		/// <param name="position">The zero-based position to search for the first editable character to replace.</param>
		/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if all the characters were successfully replaced; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008E5 RID: 2277 RVA: 0x00005958 File Offset: 0x00003B58
		[Token(Token = "0x60008E5")]
		[Address(RVA = "0xC617B0", Offset = "0xC607B0", VA = "0x180C617B0")]
		public bool Replace(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Replaces a range of editable characters between the specified starting and ending positions with the specified string, and then outputs the removal position and descriptive information.</summary>
		/// <param name="input">The <see cref="T:System.String" /> value used to replace the existing editable characters.</param>
		/// <param name="startPosition">The zero-based position in the formatted string where the replacement starts.</param>
		/// <param name="endPosition">The zero-based position in the formatted string where the replacement ends.</param>
		/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually replaced; otherwise, the first position where the operation failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the replacement operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if all the characters were successfully replaced; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008E6 RID: 2278 RVA: 0x00005970 File Offset: 0x00003B70
		[Token(Token = "0x60008E6")]
		[Address(RVA = "0xC61400", Offset = "0xC60400", VA = "0x180C61400")]
		public bool Replace(string input, int startPosition, int endPosition, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x060008E7 RID: 2279 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x60008E7")]
		[Address(RVA = "0xC61AA0", Offset = "0xC60AA0", VA = "0x180C61AA0")]
		private void ResetChar(int testPosition)
		{
		}

		// Token: 0x060008E8 RID: 2280 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x60008E8")]
		[Address(RVA = "0xC61B50", Offset = "0xC60B50", VA = "0x180C61B50")]
		private void ResetString(int startPosition, int endPosition)
		{
		}

		/// <summary>Sets the formatted string to the specified input string.</summary>
		/// <param name="input">The <see cref="T:System.String" /> value used to set the formatted string.</param>
		/// <returns>
		///   <see langword="true" /> if all the characters were successfully set; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
		// Token: 0x060008E9 RID: 2281 RVA: 0x00005988 File Offset: 0x00003B88
		[Token(Token = "0x60008E9")]
		[Address(RVA = "0xC62060", Offset = "0xC61060", VA = "0x180C62060")]
		public bool Set(string input)
		{
			return default(bool);
		}

		/// <summary>Sets the formatted string to the specified input string, and then outputs the removal position and descriptive information.</summary>
		/// <param name="input">The <see cref="T:System.String" /> value used to set the formatted string.</param>
		/// <param name="testPosition">If successful, the zero-based position in the formatted string where the last character was actually set; otherwise, the first position where the operation failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the set operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if all the characters were successfully set; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="input" /> parameter is <see langword="null" />.</exception>
		// Token: 0x060008EA RID: 2282 RVA: 0x000059A0 File Offset: 0x00003BA0
		[Token(Token = "0x60008EA")]
		[Address(RVA = "0xC621D0", Offset = "0xC611D0", VA = "0x180C621D0")]
		public bool Set(string input, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x060008EB RID: 2283 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x60008EB")]
		[Address(RVA = "0xC61CD0", Offset = "0xC60CD0", VA = "0x180C61CD0")]
		private void SetChar(char input, int position)
		{
		}

		// Token: 0x060008EC RID: 2284 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x60008EC")]
		[Address(RVA = "0xC61D60", Offset = "0xC60D60", VA = "0x180C61D60")]
		private void SetChar(char input, int position, MaskedTextProvider.CharDescriptor charDescriptor)
		{
		}

		// Token: 0x060008ED RID: 2285 RVA: 0x00002053 File Offset: 0x00000253
		[Token(Token = "0x60008ED")]
		[Address(RVA = "0xC61F30", Offset = "0xC60F30", VA = "0x180C61F30")]
		private void SetString(string input, int testPosition)
		{
		}

		// Token: 0x060008EE RID: 2286 RVA: 0x000059B8 File Offset: 0x00003BB8
		[Token(Token = "0x60008EE")]
		[Address(RVA = "0xC62320", Offset = "0xC61320", VA = "0x180C62320")]
		private bool TestChar(char input, int position, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x060008EF RID: 2287 RVA: 0x000059D0 File Offset: 0x00003BD0
		[Token(Token = "0x60008EF")]
		[Address(RVA = "0xC62850", Offset = "0xC61850", VA = "0x180C62850")]
		private bool TestEscapeChar(char input, int position)
		{
			return default(bool);
		}

		// Token: 0x060008F0 RID: 2288 RVA: 0x000059E8 File Offset: 0x00003BE8
		[Token(Token = "0x60008F0")]
		[Address(RVA = "0xC628E0", Offset = "0xC618E0", VA = "0x180C628E0")]
		private bool TestEscapeChar(char input, int position, MaskedTextProvider.CharDescriptor charDex)
		{
			return default(bool);
		}

		// Token: 0x060008F1 RID: 2289 RVA: 0x00005A00 File Offset: 0x00003C00
		[Token(Token = "0x60008F1")]
		[Address(RVA = "0xC62A80", Offset = "0xC61A80", VA = "0x180C62A80")]
		private bool TestSetChar(char input, int position, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x060008F2 RID: 2290 RVA: 0x00005A18 File Offset: 0x00003C18
		[Token(Token = "0x60008F2")]
		[Address(RVA = "0xC62AF0", Offset = "0xC61AF0", VA = "0x180C62AF0")]
		private bool TestSetString(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x060008F3 RID: 2291 RVA: 0x00005A30 File Offset: 0x00003C30
		[Token(Token = "0x60008F3")]
		[Address(RVA = "0xC62B60", Offset = "0xC61B60", VA = "0x180C62B60")]
		private bool TestString(string input, int position, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		/// <summary>Returns the formatted string in a displayable form.</summary>
		/// <returns>The formatted <see cref="T:System.String" /> that includes prompts and mask literals.</returns>
		// Token: 0x060008F4 RID: 2292 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008F4")]
		[Address(RVA = "0xC62CD0", Offset = "0xC61CD0", VA = "0x180C62CD0")]
		public string ToDisplayString()
		{
			return null;
		}

		/// <summary>Returns the formatted string that includes all the assigned character values.</summary>
		/// <returns>The formatted <see cref="T:System.String" /> that includes all the assigned character values.</returns>
		// Token: 0x060008F5 RID: 2293 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008F5")]
		[Address(RVA = "0xC63190", Offset = "0xC62190", VA = "0x180C63190", Slot = "3")]
		public override string ToString()
		{
			return null;
		}

		/// <summary>Returns the formatted string, optionally including password characters.</summary>
		/// <param name="ignorePasswordChar">
		///   <see langword="true" /> to return the actual editable characters; otherwise, <see langword="false" /> to indicate that the <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" /> property is to be honored.</param>
		/// <returns>The formatted <see cref="T:System.String" /> that includes literals, prompts, and optionally password characters.</returns>
		// Token: 0x060008F6 RID: 2294 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008F6")]
		[Address(RVA = "0xC63580", Offset = "0xC62580", VA = "0x180C63580")]
		public string ToString(bool ignorePasswordChar)
		{
			return null;
		}

		/// <summary>Returns a substring of the formatted string.</summary>
		/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
		/// <param name="length">The number of characters to return.</param>
		/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes all the assigned character values; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
		// Token: 0x060008F7 RID: 2295 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008F7")]
		[Address(RVA = "0xC63460", Offset = "0xC62460", VA = "0x180C63460")]
		public string ToString(int startPosition, int length)
		{
			return null;
		}

		/// <summary>Returns a substring of the formatted string, optionally including password characters.</summary>
		/// <param name="ignorePasswordChar">
		///   <see langword="true" /> to return the actual editable characters; otherwise, <see langword="false" /> to indicate that the <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" /> property is to be honored.</param>
		/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
		/// <param name="length">The number of characters to return.</param>
		/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes literals, prompts, and optionally password characters; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
		// Token: 0x060008F8 RID: 2296 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008F8")]
		[Address(RVA = "0xC632E0", Offset = "0xC622E0", VA = "0x180C632E0")]
		public string ToString(bool ignorePasswordChar, int startPosition, int length)
		{
			return null;
		}

		/// <summary>Returns the formatted string, optionally including prompt and literal characters.</summary>
		/// <param name="includePrompt">
		///   <see langword="true" /> to include prompt characters in the return string; otherwise, <see langword="false" />.</param>
		/// <param name="includeLiterals">
		///   <see langword="true" /> to include literal characters in the return string; otherwise, <see langword="false" />.</param>
		/// <returns>The formatted <see cref="T:System.String" /> that includes all the assigned character values and optionally includes literals and prompts.</returns>
		// Token: 0x060008F9 RID: 2297 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008F9")]
		[Address(RVA = "0xC63400", Offset = "0xC62400", VA = "0x180C63400")]
		public string ToString(bool includePrompt, bool includeLiterals)
		{
			return null;
		}

		/// <summary>Returns a substring of the formatted string, optionally including prompt and literal characters.</summary>
		/// <param name="includePrompt">
		///   <see langword="true" /> to include prompt characters in the return string; otherwise, <see langword="false" />.</param>
		/// <param name="includeLiterals">
		///   <see langword="true" /> to include literal characters in the return string; otherwise, <see langword="false" />.</param>
		/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
		/// <param name="length">The number of characters to return.</param>
		/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes all the assigned character values and optionally includes literals and prompts; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
		// Token: 0x060008FA RID: 2298 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008FA")]
		[Address(RVA = "0xC632B0", Offset = "0xC622B0", VA = "0x180C632B0")]
		public string ToString(bool includePrompt, bool includeLiterals, int startPosition, int length)
		{
			return null;
		}

		/// <summary>Returns a substring of the formatted string, optionally including prompt, literal, and password characters.</summary>
		/// <param name="ignorePasswordChar">
		///   <see langword="true" /> to return the actual editable characters; otherwise, <see langword="false" /> to indicate that the <see cref="P:System.ComponentModel.MaskedTextProvider.PasswordChar" /> property is to be honored.</param>
		/// <param name="includePrompt">
		///   <see langword="true" /> to include prompt characters in the return string; otherwise, <see langword="false" />.</param>
		/// <param name="includeLiterals">
		///   <see langword="true" /> to return literal characters in the return string; otherwise, <see langword="false" />.</param>
		/// <param name="startPosition">The zero-based position in the formatted string where the output begins.</param>
		/// <param name="length">The number of characters to return.</param>
		/// <returns>If successful, a substring of the formatted <see cref="T:System.String" />, which includes all the assigned character values and optionally includes literals, prompts, and password characters; otherwise the <see cref="F:System.String.Empty" /> string.</returns>
		// Token: 0x060008FB RID: 2299 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60008FB")]
		[Address(RVA = "0xC62E60", Offset = "0xC61E60", VA = "0x180C62E60")]
		public string ToString(bool ignorePasswordChar, bool includePrompt, bool includeLiterals, int startPosition, int length)
		{
			return null;
		}

		/// <summary>Tests whether the specified character could be set successfully at the specified position.</summary>
		/// <param name="input">The <see cref="T:System.Char" /> value to test.</param>
		/// <param name="position">The position in the mask to test the input character against.</param>
		/// <param name="hint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the specified character is valid for the specified position; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008FC RID: 2300 RVA: 0x00005A48 File Offset: 0x00003C48
		[Token(Token = "0x60008FC")]
		[Address(RVA = "0xC636B0", Offset = "0xC626B0", VA = "0x180C636B0")]
		public bool VerifyChar(char input, int position, out MaskedTextResultHint hint)
		{
			return default(bool);
		}

		/// <summary>Tests whether the specified character would be escaped at the specified position.</summary>
		/// <param name="input">The <see cref="T:System.Char" /> value to test.</param>
		/// <param name="position">The position in the mask to test the input character against.</param>
		/// <returns>
		///   <see langword="true" /> if the specified character would be escaped at the specified position; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008FD RID: 2301 RVA: 0x00005A60 File Offset: 0x00003C60
		[Token(Token = "0x60008FD")]
		[Address(RVA = "0xC63730", Offset = "0xC62730", VA = "0x180C63730")]
		public bool VerifyEscapeChar(char input, int position)
		{
			return default(bool);
		}

		/// <summary>Tests whether the specified string could be set successfully.</summary>
		/// <param name="input">The <see cref="T:System.String" /> value to test.</param>
		/// <returns>
		///   <see langword="true" /> if the specified string represents valid input; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008FE RID: 2302 RVA: 0x00005A78 File Offset: 0x00003C78
		[Token(Token = "0x60008FE")]
		[Address(RVA = "0xC637E0", Offset = "0xC627E0", VA = "0x180C637E0")]
		public bool VerifyString(string input)
		{
			return default(bool);
		}

		/// <summary>Tests whether the specified string could be set successfully, and then outputs position and descriptive information.</summary>
		/// <param name="input">The <see cref="T:System.String" /> value to test.</param>
		/// <param name="testPosition">If successful, the zero-based position of the last character actually tested; otherwise, the first position where the test failed. An output parameter.</param>
		/// <param name="resultHint">A <see cref="T:System.ComponentModel.MaskedTextResultHint" /> that succinctly describes the result of the test operation. An output parameter.</param>
		/// <returns>
		///   <see langword="true" /> if the specified string represents valid input; otherwise, <see langword="false" />.</returns>
		// Token: 0x060008FF RID: 2303 RVA: 0x00005A90 File Offset: 0x00003C90
		[Token(Token = "0x60008FF")]
		[Address(RVA = "0xC637A0", Offset = "0xC627A0", VA = "0x180C637A0")]
		public bool VerifyString(string input, out int testPosition, out MaskedTextResultHint resultHint)
		{
			return default(bool);
		}

		// Token: 0x04000529 RID: 1321
		[Token(Token = "0x4000529")]
		private const char spaceChar = ' ';

		// Token: 0x0400052A RID: 1322
		[Token(Token = "0x400052A")]
		private const char defaultPromptChar = '_';

		// Token: 0x0400052B RID: 1323
		[Token(Token = "0x400052B")]
		private const char nullPasswordChar = '\0';

		// Token: 0x0400052C RID: 1324
		[Token(Token = "0x400052C")]
		private const bool defaultAllowPrompt = true;

		// Token: 0x0400052D RID: 1325
		[Token(Token = "0x400052D")]
		private const int invalidIndex = -1;

		// Token: 0x0400052E RID: 1326
		[Token(Token = "0x400052E")]
		private const byte editAny = 0;

		// Token: 0x0400052F RID: 1327
		[Token(Token = "0x400052F")]
		private const byte editUnassigned = 1;

		// Token: 0x04000530 RID: 1328
		[Token(Token = "0x4000530")]
		private const byte editAssigned = 2;

		// Token: 0x04000531 RID: 1329
		[Token(Token = "0x4000531")]
		private const bool forward = true;

		// Token: 0x04000532 RID: 1330
		[Token(Token = "0x4000532")]
		private const bool backward = false;

		// Token: 0x04000533 RID: 1331
		[Token(Token = "0x4000533")]
		private static int ASCII_ONLY;

		// Token: 0x04000534 RID: 1332
		[Token(Token = "0x4000534")]
		private static int ALLOW_PROMPT_AS_INPUT;

		// Token: 0x04000535 RID: 1333
		[Token(Token = "0x4000535")]
		private static int INCLUDE_PROMPT;

		// Token: 0x04000536 RID: 1334
		[Token(Token = "0x4000536")]
		private static int INCLUDE_LITERALS;

		// Token: 0x04000537 RID: 1335
		[Token(Token = "0x4000537")]
		private static int RESET_ON_PROMPT;

		// Token: 0x04000538 RID: 1336
		[Token(Token = "0x4000538")]
		private static int RESET_ON_LITERALS;

		// Token: 0x04000539 RID: 1337
		[Token(Token = "0x4000539")]
		private static int SKIP_SPACE;

		// Token: 0x0400053A RID: 1338
		[Token(Token = "0x400053A")]
		private static Type maskTextProviderType;

		// Token: 0x0400053B RID: 1339
		[FieldOffset(Offset = "0x10")]
		[Token(Token = "0x400053B")]
		private BitVector32 flagState;

		// Token: 0x0400053C RID: 1340
		[FieldOffset(Offset = "0x18")]
		[Token(Token = "0x400053C")]
		private CultureInfo culture;

		// Token: 0x0400053D RID: 1341
		[FieldOffset(Offset = "0x20")]
		[Token(Token = "0x400053D")]
		private StringBuilder testString;

		// Token: 0x0400053E RID: 1342
		[FieldOffset(Offset = "0x28")]
		[Token(Token = "0x400053E")]
		private int assignedCharCount;

		// Token: 0x0400053F RID: 1343
		[FieldOffset(Offset = "0x2C")]
		[Token(Token = "0x400053F")]
		private int requiredCharCount;

		// Token: 0x04000540 RID: 1344
		[FieldOffset(Offset = "0x30")]
		[Token(Token = "0x4000540")]
		private int requiredEditChars;

		// Token: 0x04000541 RID: 1345
		[FieldOffset(Offset = "0x34")]
		[Token(Token = "0x4000541")]
		private int optionalEditChars;

		// Token: 0x04000542 RID: 1346
		[FieldOffset(Offset = "0x38")]
		[Token(Token = "0x4000542")]
		private string mask;

		// Token: 0x04000543 RID: 1347
		[FieldOffset(Offset = "0x40")]
		[Token(Token = "0x4000543")]
		private char passwordChar;

		// Token: 0x04000544 RID: 1348
		[FieldOffset(Offset = "0x42")]
		[Token(Token = "0x4000544")]
		private char promptChar;

		// Token: 0x04000545 RID: 1349
		[FieldOffset(Offset = "0x48")]
		[Token(Token = "0x4000545")]
		private List<MaskedTextProvider.CharDescriptor> stringDescriptor;

		// Token: 0x02000164 RID: 356
		[Token(Token = "0x2000164")]
		private enum CaseConversion
		{
			// Token: 0x04000547 RID: 1351
			[Token(Token = "0x4000547")]
			None,
			// Token: 0x04000548 RID: 1352
			[Token(Token = "0x4000548")]
			ToLower,
			// Token: 0x04000549 RID: 1353
			[Token(Token = "0x4000549")]
			ToUpper
		}

		// Token: 0x02000165 RID: 357
		[Token(Token = "0x2000165")]
		[Flags]
		private enum CharType
		{
			// Token: 0x0400054B RID: 1355
			[Token(Token = "0x400054B")]
			EditOptional = 1,
			// Token: 0x0400054C RID: 1356
			[Token(Token = "0x400054C")]
			EditRequired = 2,
			// Token: 0x0400054D RID: 1357
			[Token(Token = "0x400054D")]
			Separator = 4,
			// Token: 0x0400054E RID: 1358
			[Token(Token = "0x400054E")]
			Literal = 8,
			// Token: 0x0400054F RID: 1359
			[Token(Token = "0x400054F")]
			Modifier = 16
		}

		// Token: 0x02000166 RID: 358
		[Token(Token = "0x2000166")]
		private class CharDescriptor
		{
			// Token: 0x06000901 RID: 2305 RVA: 0x00002053 File Offset: 0x00000253
			[Token(Token = "0x6000901")]
			[Address(RVA = "0xC514F0", Offset = "0xC504F0", VA = "0x180C514F0")]
			public CharDescriptor(int maskPos, MaskedTextProvider.CharType charType)
			{
			}

			// Token: 0x06000902 RID: 2306 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000902")]
			[Address(RVA = "0xC512C0", Offset = "0xC502C0", VA = "0x180C512C0", Slot = "3")]
			public override string ToString()
			{
				return null;
			}

			// Token: 0x04000550 RID: 1360
			[FieldOffset(Offset = "0x10")]
			[Token(Token = "0x4000550")]
			public int MaskPosition;

			// Token: 0x04000551 RID: 1361
			[FieldOffset(Offset = "0x14")]
			[Token(Token = "0x4000551")]
			public MaskedTextProvider.CaseConversion CaseConversion;

			// Token: 0x04000552 RID: 1362
			[FieldOffset(Offset = "0x18")]
			[Token(Token = "0x4000552")]
			public MaskedTextProvider.CharType CharType;

			// Token: 0x04000553 RID: 1363
			[FieldOffset(Offset = "0x1C")]
			[Token(Token = "0x4000553")]
			public bool IsAssigned;
		}
	}
}