# encoding: utf-8
# module System.Text.RegularExpressions calls itself RegularExpressions
# from System,Version=4.0.0.0,Culture=neutral,PublicKeyToken=b77a5c561934e089
# by generator 1.145
""" NamespaceTracker represent a CLS namespace. """
# no imports

# no functions
# classes

class Capture(object):
 """ Represents the results from a single successful subexpression capture. """
 def ToString(self):
  """
  ToString(self: Capture) -> str

  

   Gets the captured substring from the input string.

   Returns: The actual substring that was captured by the match.
  """
  pass
 Index=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The position in the original string where the first character of the captured substring was found.



Get: Index(self: Capture) -> int



"""

 Length=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """The length of the captured substring.



Get: Length(self: Capture) -> int



"""

 Value=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the captured substring from the input string.



Get: Value(self: Capture) -> str



"""



class CaptureCollection(object,ICollection,IEnumerable):
 """ Represents the set of captures made by a single capturing group. """
 def CopyTo(self,array,arrayIndex):
  """
  CopyTo(self: CaptureCollection,array: Array,arrayIndex: int)

   Copies all the elements of the collection to the given array beginning at the given index.

  

   array: The array the collection is to be copied into.

   arrayIndex: The position in the destination array where copying is to begin.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: CaptureCollection) -> IEnumerator

  

   Provides an enumerator that iterates through the collection.

   Returns: An object that contains all System.Text.RegularExpressions.Capture objects within the 

    System.Text.RegularExpressions.CaptureCollection.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of substrings captured by the group.



Get: Count(self: CaptureCollection) -> int



"""

 IsReadOnly=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value that indicates whether the collection is read only.



Get: IsReadOnly(self: CaptureCollection) -> bool



"""

 IsSynchronized=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value that indicates whether access to the collection is synchronized (thread-safe).



Get: IsSynchronized(self: CaptureCollection) -> bool



"""

 SyncRoot=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets an object that can be used to synchronize access to the collection.



Get: SyncRoot(self: CaptureCollection) -> object



"""



class Group(Capture):
 """ Represents the results from a single capturing group. """
 @staticmethod
 def Synchronized(inner):
  """
  Synchronized(inner: Group) -> Group

  

   Returns a Group object equivalent to the one supplied that is safe to share between multiple 

    threads.

  

  

   inner: The input System.Text.RegularExpressions.Group object.

   Returns: A regular expression Group object.
  """
  pass
 Captures=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection of all the captures matched by the capturing group,in innermost-leftmost-first order (or innermost-rightmost-first order if the regular expression is modified with the System.Text.RegularExpressions.RegexOptions.RightToLeft option). The collection may have zero or more items.



Get: Captures(self: Group) -> CaptureCollection



"""

 Name=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Name(self: Group) -> str



"""

 Success=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value indicating whether the match is successful.



Get: Success(self: Group) -> bool



"""



class GroupCollection(object,ICollection,IEnumerable):
 """ Returns the set of captured groups in a single match. """
 def CopyTo(self,array,arrayIndex):
  """
  CopyTo(self: GroupCollection,array: Array,arrayIndex: int)

   Copies all the elements of the collection to the given array beginning at the given index.

  

   array: The array the collection is to be copied into.

   arrayIndex: The position in the destination array where the copying is to begin.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: GroupCollection) -> IEnumerator

  

   Provides an enumerator that iterates through the collection.

   Returns: An enumerator that contains all System.Text.RegularExpressions.Group objects in the 

    System.Text.RegularExpressions.GroupCollection.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y]x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Returns the number of groups in the collection.



Get: Count(self: GroupCollection) -> int



"""

 IsReadOnly=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value that indicates whether the collection is read-only.



Get: IsReadOnly(self: GroupCollection) -> bool



"""

 IsSynchronized=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value that indicates whether access to the System.Text.RegularExpressions.GroupCollection is synchronized (thread-safe).



Get: IsSynchronized(self: GroupCollection) -> bool



"""

 SyncRoot=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets an object that can be used to synchronize access to the System.Text.RegularExpressions.GroupCollection.



Get: SyncRoot(self: GroupCollection) -> object



"""



class Match(Group):
 """ Represents the results from a single regular expression match. """
 def NextMatch(self):
  """
  NextMatch(self: Match) -> Match

  

   Returns a new System.Text.RegularExpressions.Match object with the results for the next match,

    starting at the position at which the last match ended (at the character after the last matched 

    character).

  

   Returns: The next regular expression match.
  """
  pass
 def Result(self,replacement):
  """
  Result(self: Match,replacement: str) -> str

  

   Returns the expansion of the specified replacement pattern.

  

   replacement: The replacement pattern to use.

   Returns: The expanded version of the replacement parameter.
  """
  pass
 @staticmethod
 def Synchronized(inner):
  """
  Synchronized(inner: Match) -> Match

  

   Returns a System.Text.RegularExpressions.Match instance equivalent to the one supplied that is 

    suitable to share between multiple threads.

  

  

   inner: A regular expression match equivalent to the one expected.

   Returns: A regular expression match that is suitable to share between multiple threads.
  """
  pass
 Groups=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection of groups matched by the regular expression.



Get: Groups(self: Match) -> GroupCollection



"""


 Empty=None


class MatchCollection(object,ICollection,IEnumerable):
 """ Represents the set of successful matches found by iteratively applying a regular expression pattern to the input string. """
 def CopyTo(self,array,arrayIndex):
  """
  CopyTo(self: MatchCollection,array: Array,arrayIndex: int)

   Copies all the elements of the collection to the given array starting at the given index.

  

   array: The array the collection is to be copied into.

   arrayIndex: The position in the array where copying is to begin.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: MatchCollection) -> IEnumerator

  

   Provides an enumerator that iterates through the collection.

   Returns: An object that contains all System.Text.RegularExpressions.Match objects within the 

    System.Text.RegularExpressions.MatchCollection.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of matches.



Get: Count(self: MatchCollection) -> int



"""

 IsReadOnly=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value that indicates whether the collection is read only.



Get: IsReadOnly(self: MatchCollection) -> bool



"""

 IsSynchronized=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value indicating whether access to the collection is synchronized (thread-safe).



Get: IsSynchronized(self: MatchCollection) -> bool



"""

 SyncRoot=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets an object that can be used to synchronize access to the collection.



Get: SyncRoot(self: MatchCollection) -> object



"""



class MatchEvaluator(MulticastDelegate,ICloneable,ISerializable):
 """
 Represents the method that is called each time a regular expression match is found during a erload:System.Text.RegularExpressions.Regex.Replace method operation.

 

 MatchEvaluator(object: object,method: IntPtr)
 """
 def BeginInvoke(self,match,callback,object):
  """ BeginInvoke(self: MatchEvaluator,match: Match,callback: AsyncCallback,object: object) -> IAsyncResult """
  pass
 def CombineImpl(self,*args):
  """
  CombineImpl(self: MulticastDelegate,follow: Delegate) -> Delegate

  

   Combines this System.Delegate with the specified System.Delegate to form a new delegate.

  

   follow: The delegate to combine with this delegate.

   Returns: A delegate that is the new root of the System.MulticastDelegate invocation list.
  """
  pass
 def DynamicInvokeImpl(self,*args):
  """
  DynamicInvokeImpl(self: Delegate,args: Array[object]) -> object

  

   Dynamically invokes (late-bound) the method represented by the current delegate.

  

   args: An array of objects that are the arguments to pass to the method represented by the current 

    delegate.-or- null,if the method represented by the current delegate does not require 

    arguments.

  

   Returns: The object returned by the method represented by the delegate.
  """
  pass
 def EndInvoke(self,result):
  """ EndInvoke(self: MatchEvaluator,result: IAsyncResult) -> str """
  pass
 def GetMethodImpl(self,*args):
  """
  GetMethodImpl(self: MulticastDelegate) -> MethodInfo

  

   Returns a static method represented by the current System.MulticastDelegate.

   Returns: A static method represented by the current System.MulticastDelegate.
  """
  pass
 def Invoke(self,match):
  """ Invoke(self: MatchEvaluator,match: Match) -> str """
  pass
 def RemoveImpl(self,*args):
  """
  RemoveImpl(self: MulticastDelegate,value: Delegate) -> Delegate

  

   Removes an element from the invocation list of this System.MulticastDelegate that is equal to 

    the specified delegate.

  

  

   value: The delegate to search for in the invocation list.

   Returns: If value is found in the invocation list for this instance,then a new System.Delegate without 

    value in its invocation list; otherwise,this instance with its original invocation list.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 @staticmethod
 def __new__(self,object,method):
  """ __new__(cls: type,object: object,method: IntPtr) """
  pass
 def __reduce_ex__(self,*args):
  pass

class Regex(object,ISerializable):
 """
 Represents an immutable regular expression.

 

 Regex(pattern: str)

 Regex(pattern: str,options: RegexOptions)

 Regex(pattern: str,options: RegexOptions,matchTimeout: TimeSpan)
 """
 @staticmethod
 def CompileToAssembly(regexinfos,assemblyname,attributes=None,resourceFile=None):
  """
  CompileToAssembly(regexinfos: Array[RegexCompilationInfo],assemblyname: AssemblyName,attributes: Array[CustomAttributeBuilder],resourceFile: str)

   Compiles one or more specified System.Text.RegularExpressions.Regex objects and a specified 

    resource file to a named assembly with the specified attributes.

  

  

   regexinfos: An array that describes the regular expressions to compile.

   assemblyname: The file name of the assembly.

   attributes: An array that defines the attributes to apply to the assembly.

   resourceFile: The name of the Win32 resource file to include in the assembly.

  CompileToAssembly(regexinfos: Array[RegexCompilationInfo],assemblyname: AssemblyName,attributes: Array[CustomAttributeBuilder])

   Compiles one or more specified System.Text.RegularExpressions.Regex objects to a named assembly 

    with the specified attributes.

  

  

   regexinfos: An array that describes the regular expressions to compile.

   assemblyname: The file name of the assembly.

   attributes: An array that defines the attributes to apply to the assembly.

  CompileToAssembly(regexinfos: Array[RegexCompilationInfo],assemblyname: AssemblyName)

   Compiles one or more specified System.Text.RegularExpressions.Regex objects to a named assembly.

  

   regexinfos: An array that describes the regular expressions to compile.

   assemblyname: The file name of the assembly.
  """
  pass
 @staticmethod
 def Escape(str):
  """
  Escape(str: str) -> str

  

   Escapes a minimal set of characters (\,*,+,?,|,{,[,(,),^,$,.,#,and white space) by 

    replacing them with their escape codes. This instructs the regular expression engine to 

    interpret these characters literally rather than as metacharacters.

  

  

   str: The input string that contains the text to convert.

   Returns: A string of characters with metacharacters converted to their escaped form.
  """
  pass
 def GetGroupNames(self):
  """
  GetGroupNames(self: Regex) -> Array[str]

  

   Returns an array of capturing group names for the regular expression.

   Returns: A string array of group names.
  """
  pass
 def GetGroupNumbers(self):
  """
  GetGroupNumbers(self: Regex) -> Array[int]

  

   Returns an array of capturing group numbers that correspond to group names in an array.

   Returns: An integer array of group numbers.
  """
  pass
 def GroupNameFromNumber(self,i):
  """
  GroupNameFromNumber(self: Regex,i: int) -> str

  

   Gets the group name that corresponds to the specified group number.

  

   i: The group number to convert to the corresponding group name.

   Returns: A string that contains the group name associated with the specified group number. If there is no 

    group name that corresponds to i,the method returns System.String.Empty.
  """
  pass
 def GroupNumberFromName(self,name):
  """
  GroupNumberFromName(self: Regex,name: str) -> int

  

   Returns the group number that corresponds to the specified group name.

  

   name: The group name to convert to the corresponding group number.

   Returns: The group number that corresponds to the specified group name,or -1 if name is not a valid 

    group name.
  """
  pass
 def InitializeReferences(self,*args):
  """
  InitializeReferences(self: Regex)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 @staticmethod
 def IsMatch(input,*__args):
  """
  IsMatch(self: Regex,input: str) -> bool

  

   Indicates whether the regular expression specified in the System.Text.RegularExpressions.Regex 

    constructor finds a match in a specified input string.

  

  

   input: The string to search for a match.

   Returns: true if the regular expression finds a match; otherwise,false.

  IsMatch(self: Regex,input: str,startat: int) -> bool

  

   Indicates whether the regular expression specified in the System.Text.RegularExpressions.Regex 

    constructor finds a match in the specified input string,beginning at the specified starting 

    position in the string.

  

  

   input: The string to search for a match.

   startat: The character position at which to start the search.

   Returns: true if the regular expression finds a match; otherwise,false.

  IsMatch(input: str,pattern: str,options: RegexOptions,matchTimeout: TimeSpan) -> bool

  IsMatch(input: str,pattern: str) -> bool

  

   Indicates whether the specified regular expression finds a match in the specified input string.

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   Returns: true if the regular expression finds a match; otherwise,false.

  IsMatch(input: str,pattern: str,options: RegexOptions) -> bool

  

   Indicates whether the specified regular expression finds a match in the specified input string,

    using the specified matching options.

  

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   options: A bitwise combination of the enumeration values that provide options for matching.

   Returns: true if the regular expression finds a match; otherwise,false.
  """
  pass
 @staticmethod
 def Match(input,*__args):
  """
  Match(self: Regex,input: str) -> Match

  

   Searches the specified input string for the first occurrence of the regular expression specified 

    in the System.Text.RegularExpressions.Regex constructor.

  

  

   input: The string to search for a match.

   Returns: An object that contains information about the match.

  Match(self: Regex,input: str,startat: int) -> Match

  

   Searches the input string for the first occurrence of a regular expression,beginning at the 

    specified starting position in the string.

  

  

   input: The string to search for a match.

   startat: The zero-based character position at which to start the search.

   Returns: An object that contains information about the match.

  Match(self: Regex,input: str,beginning: int,length: int) -> Match

  

   Searches the input string for the first occurrence of a regular expression,beginning at the 

    specified starting position and searching only the specified number of characters.

  

  

   input: The string to search for a match.

   beginning: The zero-based character position in the input string that defines the leftmost position to be 

    searched.

  

   length: The number of characters in the substring to include in the search.

   Returns: An object that contains information about the match.

  Match(input: str,pattern: str) -> Match

  

   Searches the specified input string for the first occurrence of the specified regular expression.

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   Returns: An object that contains information about the match.

  Match(input: str,pattern: str,options: RegexOptions) -> Match

  

   Searches the input string for the first occurrence of the specified regular expression,using 

    the specified matching options.

  

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   options: A bitwise combination of the enumeration values that provide options for matching.

   Returns: An object that contains information about the match.

  Match(input: str,pattern: str,options: RegexOptions,matchTimeout: TimeSpan) -> Match
  """
  pass
 @staticmethod
 def Matches(input,*__args):
  """
  Matches(self: Regex,input: str) -> MatchCollection

  

   Searches the specified input string for all occurrences of a regular expression.

  

   input: The string to search for a match.

   Returns: A collection of the System.Text.RegularExpressions.Match objects found by the search. If no 

    matches are found,the method returns an empty collection object.

  

  Matches(self: Regex,input: str,startat: int) -> MatchCollection

  

   Searches the specified input string for all occurrences of a regular expression,beginning at 

    the specified starting position in the string.

  

  

   input: The string to search for a match.

   startat: The character position in the input string at which to start the search.

   Returns: A collection of the System.Text.RegularExpressions.Match objects found by the search. If no 

    matches are found,the method returns an empty collection object.

  

  Matches(input: str,pattern: str,options: RegexOptions,matchTimeout: TimeSpan) -> MatchCollection

  Matches(input: str,pattern: str) -> MatchCollection

  

   Searches the specified input string for all occurrences of a specified regular expression.

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   Returns: A collection of the System.Text.RegularExpressions.Match objects found by the search. If no 

    matches are found,the method returns an empty collection object.

  

  Matches(input: str,pattern: str,options: RegexOptions) -> MatchCollection

  

   Searches the specified input string for all occurrences of a specified regular expression,using 

    the specified matching options.

  

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   options: A bitwise combination of the enumeration values that specify options for matching.

   Returns: A collection of the System.Text.RegularExpressions.Match objects found by the search. If no 

    matches are found,the method returns an empty collection object.
  """
  pass
 @staticmethod
 def Replace(input,*__args):
  """
  Replace(input: str,pattern: str,evaluator: MatchEvaluator,options: RegexOptions,matchTimeout: TimeSpan) -> str

  Replace(input: str,pattern: str,evaluator: MatchEvaluator,options: RegexOptions) -> str

  

   Within a specified input string,replaces all strings that match a specified regular expression 

    with a string returned by a System.Text.RegularExpressions.MatchEvaluator delegate. Specified 

    options modify the matching operation.

  

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   evaluator: A custom method that examines each match and returns either the original matched string or a 

    replacement string.

  

   options: A bitwise combination of the enumeration values that provide options for matching.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(input: str,pattern: str,evaluator: MatchEvaluator) -> str

  

   Within a specified input string,replaces all strings that match a specified regular expression 

    with a string returned by a System.Text.RegularExpressions.MatchEvaluator delegate.

  

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   evaluator: A custom method that examines each match and returns either the original matched string or a 

    replacement string.

  

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(self: Regex,input: str,evaluator: MatchEvaluator,count: int,startat: int) -> str

  

   Within a specified input substring,replaces a specified maximum number of strings that match a 

    regular expression pattern with a string returned by a 

    System.Text.RegularExpressions.MatchEvaluator delegate.

  

  

   input: The string to search for a match.

   evaluator: A custom method that examines each match and returns either the original matched string or a 

    replacement string.

  

   count: The maximum number of times the replacement will occur.

   startat: The character position in the input string where the search begins.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(self: Regex,input: str,evaluator: MatchEvaluator,count: int) -> str

  

   Within a specified input string,replaces a specified maximum number of strings that match a 

    regular expression pattern with a string returned by a 

    System.Text.RegularExpressions.MatchEvaluator delegate.

  

  

   input: The string to search for a match.

   evaluator: A custom method that examines each match and returns either the original matched string or a 

    replacement string.

  

   count: The maximum number of times the replacement will occur.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(self: Regex,input: str,evaluator: MatchEvaluator) -> str

  

   Within a specified input string,replaces all strings that match a specified regular expression 

    with a string returned by a System.Text.RegularExpressions.MatchEvaluator delegate.

  

  

   input: The string to search for a match.

   evaluator: A custom method that examines each match and returns either the original matched string or a 

    replacement string.

  

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(input: str,pattern: str,replacement: str,options: RegexOptions,matchTimeout: TimeSpan) -> str

  Replace(input: str,pattern: str,replacement: str,options: RegexOptions) -> str

  

   Within a specified input string,replaces all strings that match a specified regular expression 

    with a specified replacement string. Specified options modify the matching operation.

  

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   replacement: The replacement string.

   options: A bitwise combination of the enumeration values that provide options for matching.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(input: str,pattern: str,replacement: str) -> str

  

   Within a specified input string,replaces all strings that match a specified regular expression 

    with a specified replacement string.

  

  

   input: The string to search for a match.

   pattern: The regular expression pattern to match.

   replacement: The replacement string.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(self: Regex,input: str,replacement: str,count: int,startat: int) -> str

  

   Within a specified input substring,replaces a specified maximum number of strings that match a 

    regular expression pattern with a specified replacement string.

  

  

   input: The string to search for a match.

   replacement: The replacement string.

   count: Maximum number of times the replacement can occur.

   startat: The character position in the input string where the search begins.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(self: Regex,input: str,replacement: str,count: int) -> str

  

   Within a specified input string,replaces a specified maximum number of strings that match a 

    regular expression pattern with a specified replacement string.

  

  

   input: The string to search for a match.

   replacement: The replacement string.

   count: The maximum number of times the replacement can occur.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.

  

  Replace(self: Regex,input: str,replacement: str) -> str

  

   Within a specified input string,replaces all strings that match a regular expression pattern 

    with a specified replacement string.

  

  

   input: The string to search for a match.

   replacement: The replacement string.

   Returns: A new string that is identical to the input string,except that a replacement string takes the 

    place of each matched string.
  """
  pass
 @staticmethod
 def Split(input,*__args):
  """
  Split(self: Regex,input: str) -> Array[str]

  

   Splits the specified input string at the positions defined by a regular expression pattern 

    specified in the System.Text.RegularExpressions.Regex constructor.

  

  

   input: The string to split.

   Returns: An array of strings.

  Split(self: Regex,input: str,count: int) -> Array[str]

  

   Splits the specified input string a specified maximum number of times at the positions defined 

    by a regular expression specified in the System.Text.RegularExpressions.Regex constructor.

  

  

   input: The string to be split.

   count: The maximum number of times the split can occur.

   Returns: An array of strings.

  Split(self: Regex,input: str,count: int,startat: int) -> Array[str]

  

   Splits the specified input string a specified maximum number of times at the positions defined 

    by a regular expression specified in the System.Text.RegularExpressions.Regex constructor. The 

    search for the regular expression pattern starts at a specified character position in the input 

    string.

  

  

   input: The string to be split.

   count: The maximum number of times the split can occur.

   startat: The character position in the input string where the search will begin.

   Returns: An array of strings.

  Split(input: str,pattern: str) -> Array[str]

  

   Splits the input string at the positions defined by a regular expression pattern.

  

   input: The string to split.

   pattern: The regular expression pattern to match.

   Returns: An array of strings.

  Split(input: str,pattern: str,options: RegexOptions) -> Array[str]

  

   Splits the input string at the positions defined by a specified regular expression pattern. 

    Specified options modify the matching operation.

  

  

   input: The string to split.

   pattern: The regular expression pattern to match.

   options: A bitwise combination of the enumeration values that provide options for matching.

   Returns: An array of strings.

  Split(input: str,pattern: str,options: RegexOptions,matchTimeout: TimeSpan) -> Array[str]
  """
  pass
 def ToString(self):
  """
  ToString(self: Regex) -> str

  

   Returns the regular expression pattern that was passed into the Regex constructor.

   Returns: The pattern parameter that was passed into the Regex constructor.
  """
  pass
 @staticmethod
 def Unescape(str):
  """
  Unescape(str: str) -> str

  

   Converts any escaped characters in the input string.

  

   str: The input string containing the text to convert.

   Returns: A string of characters with any escaped characters converted to their unescaped form.
  """
  pass
 def UseOptionC(self,*args):
  """
  UseOptionC(self: Regex) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.

  

   Returns: true if the System.Text.RegularExpressions.Regex.Options property contains the 

    System.Text.RegularExpressions.RegexOptions.Compiled option; otherwise,false.
  """
  pass
 def UseOptionR(self,*args):
  """
  UseOptionR(self: Regex) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.

  

   Returns: true if the System.Text.RegularExpressions.Regex.Options property contains the 

    System.Text.RegularExpressions.RegexOptions.RightToLeft option; otherwise,false.
  """
  pass
 def ValidateMatchTimeout(self,*args):
  """ ValidateMatchTimeout(matchTimeout: TimeSpan) """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 @staticmethod
 def __new__(self,pattern,options=None,matchTimeout=None):
  """
  __new__(cls: type)

  __new__(cls: type,pattern: str)

  __new__(cls: type,pattern: str,options: RegexOptions)

  __new__(cls: type,pattern: str,options: RegexOptions,matchTimeout: TimeSpan)

  __new__(cls: type,info: SerializationInfo,context: StreamingContext)
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 def __str__(self,*args):
  pass
 MatchTimeout=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: MatchTimeout(self: Regex) -> TimeSpan



"""

 Options=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Returns the options passed into the System.Text.RegularExpressions.Regex constructor.



Get: Options(self: Regex) -> RegexOptions



"""

 RightToLeft=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value indicating whether the regular expression searches from right to left.



Get: RightToLeft(self: Regex) -> bool



"""


 CacheSize=15
 capnames=None
 caps=None
 capsize=None
 capslist=None
 factory=None
 InfiniteMatchTimeout=None
 internalMatchTimeout=None
 pattern=None
 roptions=None


class RegexCompilationInfo(object):
 """
 Provides information about a regular expression that is used to compile a regular expression to a stand-alone assembly.

 

 RegexCompilationInfo(pattern: str,options: RegexOptions,name: str,fullnamespace: str,ispublic: bool)

 RegexCompilationInfo(pattern: str,options: RegexOptions,name: str,fullnamespace: str,ispublic: bool,matchTimeout: TimeSpan)
 """
 @staticmethod
 def __new__(self,pattern,options,name,fullnamespace,ispublic,matchTimeout=None):
  """
  __new__(cls: type,pattern: str,options: RegexOptions,name: str,fullnamespace: str,ispublic: bool)

  __new__(cls: type,pattern: str,options: RegexOptions,name: str,fullnamespace: str,ispublic: bool,matchTimeout: TimeSpan)
  """
  pass
 IsPublic=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets a value that indicates whether the compiled regular expression has public visibility.



Get: IsPublic(self: RegexCompilationInfo) -> bool



Set: IsPublic(self: RegexCompilationInfo)=value

"""

 MatchTimeout=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: MatchTimeout(self: RegexCompilationInfo) -> TimeSpan



Set: MatchTimeout(self: RegexCompilationInfo)=value

"""

 Name=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the name of the type that represents the compiled regular expression.



Get: Name(self: RegexCompilationInfo) -> str



Set: Name(self: RegexCompilationInfo)=value

"""

 Namespace=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the namespace to which the new type belongs.



Get: Namespace(self: RegexCompilationInfo) -> str



Set: Namespace(self: RegexCompilationInfo)=value

"""

 Options=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the options to use when compiling the regular expression.



Get: Options(self: RegexCompilationInfo) -> RegexOptions



Set: Options(self: RegexCompilationInfo)=value

"""

 Pattern=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the regular expression to compile.



Get: Pattern(self: RegexCompilationInfo) -> str



Set: Pattern(self: RegexCompilationInfo)=value

"""



class RegexMatchTimeoutException(TimeoutException,ISerializable,_Exception):
 """
 RegexMatchTimeoutException(regexInput: str,regexPattern: str,matchTimeout: TimeSpan)

 RegexMatchTimeoutException()

 RegexMatchTimeoutException(message: str)

 RegexMatchTimeoutException(message: str,inner: Exception)
 """
 def add_SerializeObjectState(self,*args):
  """ add_SerializeObjectState(self: Exception,value: EventHandler[SafeSerializationEventArgs]) """
  pass
 def remove_SerializeObjectState(self,*args):
  """ remove_SerializeObjectState(self: Exception,value: EventHandler[SafeSerializationEventArgs]) """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type,regexInput: str,regexPattern: str,matchTimeout: TimeSpan)

  __new__(cls: type)

  __new__(cls: type,message: str)

  __new__(cls: type,message: str,inner: Exception)

  __new__(cls: type,info: SerializationInfo,context: StreamingContext)
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Input=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Input(self: RegexMatchTimeoutException) -> str



"""

 MatchTimeout=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: MatchTimeout(self: RegexMatchTimeoutException) -> TimeSpan



"""

 Pattern=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Pattern(self: RegexMatchTimeoutException) -> str



"""



class RegexOptions(Enum,IComparable,IFormattable,IConvertible):
 """
 Provides enumerated values to use to set regular expression options.

 

 enum (flags) RegexOptions,values: Compiled (8),CultureInvariant (512),ECMAScript (256),ExplicitCapture (4),IgnoreCase (1),IgnorePatternWhitespace (32),Multiline (2),None (0),RightToLeft (64),Singleline (16)
 """
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
  pass
 def __format__(self,*args):
  """ __format__(formattable: IFormattable,format: str) -> str """
  pass
 def __ge__(self,*args):
  pass
 def __gt__(self,*args):
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __le__(self,*args):
  pass
 def __lt__(self,*args):
  pass
 def __ne__(self,*args):
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass
 Compiled=None
 CultureInvariant=None
 ECMAScript=None
 ExplicitCapture=None
 IgnoreCase=None
 IgnorePatternWhitespace=None
 Multiline=None
 None=None
 RightToLeft=None
 Singleline=None
 value__=None


class RegexRunner(object):
 """ The System.Text.RegularExpressions.RegexRunner class is the base class for compiled regular expressions. """
 def Capture(self,*args):
  """
  Capture(self: RegexRunner,capnum: int,start: int,end: int)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def CharInClass(self,*args):
  """
  CharInClass(ch: Char,charClass: str) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method. Determines whether a 

    character is in a character class.

  

  

   ch: A character to test.

   charClass: The internal name of a character class.

   Returns: true if the ch parameter is in the character class specified by the charClass parameter.
  """
  pass
 def CharInSet(self,*args):
  """
  CharInSet(ch: Char,set: str,category: str) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def CheckTimeout(self,*args):
  """ CheckTimeout(self: RegexRunner) """
  pass
 def Crawl(self,*args):
  """
  Crawl(self: RegexRunner,i: int)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def Crawlpos(self,*args):
  """
  Crawlpos(self: RegexRunner) -> int

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def DoubleCrawl(self,*args):
  """
  DoubleCrawl(self: RegexRunner)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def DoubleStack(self,*args):
  """
  DoubleStack(self: RegexRunner)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def DoubleTrack(self,*args):
  """
  DoubleTrack(self: RegexRunner)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def EnsureStorage(self,*args):
  """
  EnsureStorage(self: RegexRunner)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def FindFirstChar(self,*args):
  """
  FindFirstChar(self: RegexRunner) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def Go(self,*args):
  """
  Go(self: RegexRunner)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def InitTrackCount(self,*args):
  """
  InitTrackCount(self: RegexRunner)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def IsBoundary(self,*args):
  """
  IsBoundary(self: RegexRunner,index: int,startpos: int,endpos: int) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def IsECMABoundary(self,*args):
  """
  IsECMABoundary(self: RegexRunner,index: int,startpos: int,endpos: int) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def IsMatched(self,*args):
  """
  IsMatched(self: RegexRunner,cap: int) -> bool

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def MatchIndex(self,*args):
  """
  MatchIndex(self: RegexRunner,cap: int) -> int

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def MatchLength(self,*args):
  """
  MatchLength(self: RegexRunner,cap: int) -> int

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def Popcrawl(self,*args):
  """
  Popcrawl(self: RegexRunner) -> int

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def Scan(self,*args):
  """
  Scan(self: RegexRunner,regex: Regex,text: str,textbeg: int,textend: int,textstart: int,prevlen: int,quick: bool,timeout: TimeSpan) -> Match

  Scan(self: RegexRunner,regex: Regex,text: str,textbeg: int,textend: int,textstart: int,prevlen: int,quick: bool) -> Match

  

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def TransferCapture(self,*args):
  """
  TransferCapture(self: RegexRunner,capnum: int,uncapnum: int,start: int,end: int)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 def Uncapture(self,*args):
  """
  Uncapture(self: RegexRunner)

   Used by a System.Text.RegularExpressions.Regex object generated by the 

    erload:System.Text.RegularExpressions.Regex.CompileToAssembly method.
  """
  pass
 runcrawl=None
 runcrawlpos=None
 runmatch=None
 runregex=None
 runstack=None
 runstackpos=None
 runtext=None
 runtextbeg=None
 runtextend=None
 runtextpos=None
 runtextstart=None
 runtrack=None
 runtrackcount=None
 runtrackpos=None


class RegexRunnerFactory(object):
 """ Creates a System.Text.RegularExpressions.RegexRunner class for a compiled regular expression. """
 def CreateInstance(self,*args):
  """
  CreateInstance(self: RegexRunnerFactory) -> RegexRunner

  

   When overridden in a derived class,creates a System.Text.RegularExpressions.RegexRunner object 

    for a specific compiled regular expression.

  

   Returns: A System.Text.RegularExpressions.RegexRunner object designed to execute a specific compiled 

    regular expression.
  """
  pass

