// Generated by Lisette bindgen
// Source: regexp (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.11

import "go:io"

pub fn Compile(expr: string) -> Result<Ref<Regexp>, error>

pub fn CompilePOSIX(expr: string) -> Result<Ref<Regexp>, error>

/// Match reports whether the byte slice b
/// contains any match of the regular expression pattern.
/// More complicated queries need to use [Compile] and the full [Regexp] interface.
pub fn Match(pattern: string, b: Slice<uint8>) -> Result<bool, error>

/// MatchReader reports whether the text returned by the [io.RuneReader]
/// contains any match of the regular expression pattern.
/// More complicated queries need to use [Compile] and the full [Regexp] interface.
pub fn MatchReader(pattern: string, r: io.RuneReader) -> Result<bool, error>

/// MatchString reports whether the string s
/// contains any match of the regular expression pattern.
/// More complicated queries need to use [Compile] and the full [Regexp] interface.
pub fn MatchString(pattern: string, s: string) -> Result<bool, error>

pub fn MustCompile(str: string) -> Ref<Regexp>

pub fn MustCompilePOSIX(str: string) -> Ref<Regexp>

/// QuoteMeta returns a string that escapes all regular expression metacharacters
/// inside the argument text; the returned string is a regular expression matching
/// the literal text.
pub fn QuoteMeta(s: string) -> string

/// Regexp is the representation of a compiled regular expression.
/// A Regexp is safe for concurrent use by multiple goroutines,
/// except for configuration methods, such as [Regexp.Longest].
pub type Regexp

impl Regexp {
  /// AppendText implements [encoding.TextAppender]. The output
  /// matches that of calling the [Regexp.String] method.
  /// 
  /// Note that the output is lossy in some cases: This method does not indicate
  /// POSIX regular expressions (i.e. those compiled by calling [CompilePOSIX]), or
  /// those for which the [Regexp.Longest] method has been called.
  fn AppendText(self: Ref<Regexp>, mut b: Slice<uint8>) -> Result<Slice<uint8>, error>

  /// Copy returns a new [Regexp] object copied from re.
  /// Calling [Regexp.Longest] on one copy does not affect another.
  /// 
  /// Deprecated: In earlier releases, when using a [Regexp] in multiple goroutines,
  /// giving each goroutine its own copy helped to avoid lock contention.
  /// As of Go 1.12, using Copy is no longer necessary to avoid lock contention.
  /// Copy may still be appropriate if the reason for its use is to make
  /// two copies with different [Regexp.Longest] settings.
  fn Copy(self: Ref<Regexp>) -> Ref<Regexp>

  /// Expand appends template to dst and returns the result; during the
  /// append, Expand replaces variables in the template with corresponding
  /// matches drawn from src. The match slice should have been returned by
  /// [Regexp.FindSubmatchIndex].
  /// 
  /// In the template, a variable is denoted by a substring of the form
  /// $name or ${name}, where name is a non-empty sequence of letters,
  /// digits, and underscores. A purely numeric name like $1 refers to
  /// the submatch with the corresponding index; other names refer to
  /// capturing parentheses named with the (?P<name>...) syntax. A
  /// reference to an out of range or unmatched index or a name that is not
  /// present in the regular expression is replaced with an empty slice.
  /// 
  /// In the $name form, name is taken to be as long as possible: $1x is
  /// equivalent to ${1x}, not ${1}x, and, $10 is equivalent to ${10}, not ${1}0.
  /// 
  /// To insert a literal $ in the output, use $$ in the template.
  fn Expand(
    self: Ref<Regexp>,
    mut dst: Slice<uint8>,
    template: Slice<uint8>,
    src: Slice<uint8>,
    match_: Slice<int>,
  ) -> Slice<uint8>

  /// ExpandString is like [Regexp.Expand] but the template and source are strings.
  /// It appends to and returns a byte slice in order to give the calling
  /// code control over allocation.
  fn ExpandString(
    self: Ref<Regexp>,
    mut dst: Slice<uint8>,
    template: string,
    src: string,
    match_: Slice<int>,
  ) -> Slice<uint8>

  /// Find returns a slice holding the text of the leftmost match in b of the regular expression.
  /// A return value of nil indicates no match.
  fn Find(self: Ref<Regexp>, b: Slice<uint8>) -> Slice<uint8>

  /// FindAll is the 'All' version of [Regexp.Find]; it returns a slice of all successive
  /// matches of the expression, as defined by the 'All' description in the
  /// package comment.
  /// A return value of nil indicates no match.
  fn FindAll(self: Ref<Regexp>, b: Slice<uint8>, n: int) -> Slice<Slice<uint8>>

  /// FindAllIndex is the 'All' version of [Regexp.FindIndex]; it returns a slice of all
  /// successive matches of the expression, as defined by the 'All' description
  /// in the package comment.
  /// A return value of nil indicates no match.
  fn FindAllIndex(self: Ref<Regexp>, b: Slice<uint8>, n: int) -> Slice<Slice<int>>

  /// FindAllString is the 'All' version of [Regexp.FindString]; it returns a slice of all
  /// successive matches of the expression, as defined by the 'All' description
  /// in the package comment.
  /// A return value of nil indicates no match.
  fn FindAllString(self: Ref<Regexp>, s: string, n: int) -> Slice<string>

  /// FindAllStringIndex is the 'All' version of [Regexp.FindStringIndex]; it returns a
  /// slice of all successive matches of the expression, as defined by the 'All'
  /// description in the package comment.
  /// A return value of nil indicates no match.
  fn FindAllStringIndex(self: Ref<Regexp>, s: string, n: int) -> Slice<Slice<int>>

  /// FindAllStringSubmatch is the 'All' version of [Regexp.FindStringSubmatch]; it
  /// returns a slice of all successive matches of the expression, as defined by
  /// the 'All' description in the package comment.
  /// A return value of nil indicates no match.
  fn FindAllStringSubmatch(self: Ref<Regexp>, s: string, n: int) -> Slice<Slice<string>>

  /// FindAllStringSubmatchIndex is the 'All' version of
  /// [Regexp.FindStringSubmatchIndex]; it returns a slice of all successive matches of
  /// the expression, as defined by the 'All' description in the package
  /// comment.
  /// A return value of nil indicates no match.
  fn FindAllStringSubmatchIndex(self: Ref<Regexp>, s: string, n: int) -> Slice<Slice<int>>

  /// FindAllSubmatch is the 'All' version of [Regexp.FindSubmatch]; it returns a slice
  /// of all successive matches of the expression, as defined by the 'All'
  /// description in the package comment.
  /// A return value of nil indicates no match.
  fn FindAllSubmatch(self: Ref<Regexp>, b: Slice<uint8>, n: int) -> Slice<Slice<Slice<uint8>>>

  /// FindAllSubmatchIndex is the 'All' version of [Regexp.FindSubmatchIndex]; it returns
  /// a slice of all successive matches of the expression, as defined by the
  /// 'All' description in the package comment.
  /// A return value of nil indicates no match.
  fn FindAllSubmatchIndex(self: Ref<Regexp>, b: Slice<uint8>, n: int) -> Slice<Slice<int>>

  /// FindIndex returns a two-element slice of integers defining the location of
  /// the leftmost match in b of the regular expression. The match itself is at
  /// b[loc[0]:loc[1]].
  /// A return value of nil indicates no match.
  fn FindIndex(self: Ref<Regexp>, b: Slice<uint8>) -> Slice<int>

  /// FindReaderIndex returns a two-element slice of integers defining the
  /// location of the leftmost match of the regular expression in text read from
  /// the [io.RuneReader]. The match text was found in the input stream at
  /// byte offset loc[0] through loc[1]-1.
  /// A return value of nil indicates no match.
  fn FindReaderIndex(self: Ref<Regexp>, r: io.RuneReader) -> Slice<int>

  /// FindReaderSubmatchIndex returns a slice holding the index pairs
  /// identifying the leftmost match of the regular expression of text read by
  /// the [io.RuneReader], and the matches, if any, of its subexpressions, as defined
  /// by the 'Submatch' and 'Index' descriptions in the package comment. A
  /// return value of nil indicates no match.
  fn FindReaderSubmatchIndex(self: Ref<Regexp>, r: io.RuneReader) -> Slice<int>

  /// FindString returns a string holding the text of the leftmost match in s of the regular
  /// expression. If there is no match, the return value is an empty string,
  /// but it will also be empty if the regular expression successfully matches
  /// an empty string. Use [Regexp.FindStringIndex] or [Regexp.FindStringSubmatch] if it is
  /// necessary to distinguish these cases.
  fn FindString(self: Ref<Regexp>, s: string) -> string

  /// FindStringIndex returns a two-element slice of integers defining the
  /// location of the leftmost match in s of the regular expression. The match
  /// itself is at s[loc[0]:loc[1]].
  /// A return value of nil indicates no match.
  fn FindStringIndex(self: Ref<Regexp>, s: string) -> Slice<int>

  /// FindStringSubmatch returns a slice of strings holding the text of the
  /// leftmost match of the regular expression in s and the matches, if any, of
  /// its subexpressions, as defined by the 'Submatch' description in the
  /// package comment.
  /// A return value of nil indicates no match.
  fn FindStringSubmatch(self: Ref<Regexp>, s: string) -> Slice<string>

  /// FindStringSubmatchIndex returns a slice holding the index pairs
  /// identifying the leftmost match of the regular expression in s and the
  /// matches, if any, of its subexpressions, as defined by the 'Submatch' and
  /// 'Index' descriptions in the package comment.
  /// A return value of nil indicates no match.
  fn FindStringSubmatchIndex(self: Ref<Regexp>, s: string) -> Slice<int>

  /// FindSubmatch returns a slice of slices holding the text of the leftmost
  /// match of the regular expression in b and the matches, if any, of its
  /// subexpressions, as defined by the 'Submatch' descriptions in the package
  /// comment.
  /// A return value of nil indicates no match.
  fn FindSubmatch(self: Ref<Regexp>, b: Slice<uint8>) -> Slice<Slice<uint8>>

  /// FindSubmatchIndex returns a slice holding the index pairs identifying the
  /// leftmost match of the regular expression in b and the matches, if any, of
  /// its subexpressions, as defined by the 'Submatch' and 'Index' descriptions
  /// in the package comment.
  /// A return value of nil indicates no match.
  fn FindSubmatchIndex(self: Ref<Regexp>, b: Slice<uint8>) -> Slice<int>

  /// LiteralPrefix returns a literal string that must begin any match
  /// of the regular expression re. It returns the boolean true if the
  /// literal string comprises the entire regular expression.
  fn LiteralPrefix(self: Ref<Regexp>) -> (string, bool)

  /// Longest makes future searches prefer the leftmost-longest match.
  /// That is, when matching against text, the regexp returns a match that
  /// begins as early as possible in the input (leftmost), and among those
  /// it chooses a match that is as long as possible.
  /// This method modifies the [Regexp] and may not be called concurrently
  /// with any other methods.
  fn Longest(self: Ref<Regexp>)

  /// MarshalText implements [encoding.TextMarshaler]. The output
  /// matches that of calling the [Regexp.AppendText] method.
  /// 
  /// See [Regexp.AppendText] for more information.
  fn MarshalText(self: Ref<Regexp>) -> Result<Slice<uint8>, error>

  /// Match reports whether the byte slice b
  /// contains any match of the regular expression re.
  fn Match(self: Ref<Regexp>, b: Slice<uint8>) -> bool

  /// MatchReader reports whether the text returned by the [io.RuneReader]
  /// contains any match of the regular expression re.
  fn MatchReader(self: Ref<Regexp>, r: io.RuneReader) -> bool

  /// MatchString reports whether the string s
  /// contains any match of the regular expression re.
  fn MatchString(self: Ref<Regexp>, s: string) -> bool

  /// NumSubexp returns the number of parenthesized subexpressions in this [Regexp].
  fn NumSubexp(self: Ref<Regexp>) -> int

  /// ReplaceAll returns a copy of src, replacing matches of the [Regexp]
  /// with the replacement text repl.
  /// Inside repl, $ signs are interpreted as in [Regexp.Expand].
  fn ReplaceAll(self: Ref<Regexp>, src: Slice<uint8>, repl: Slice<uint8>) -> Slice<uint8>

  /// ReplaceAllFunc returns a copy of src in which all matches of the
  /// [Regexp] have been replaced by the return value of function repl applied
  /// to the matched byte slice. The replacement returned by repl is substituted
  /// directly, without using [Regexp.Expand].
  fn ReplaceAllFunc(
    self: Ref<Regexp>,
    src: Slice<uint8>,
    repl: fn(Slice<uint8>) -> Slice<uint8>,
  ) -> Slice<uint8>

  /// ReplaceAllLiteral returns a copy of src, replacing matches of the [Regexp]
  /// with the replacement bytes repl. The replacement repl is substituted directly,
  /// without using [Regexp.Expand].
  fn ReplaceAllLiteral(self: Ref<Regexp>, src: Slice<uint8>, repl: Slice<uint8>) -> Slice<uint8>

  /// ReplaceAllLiteralString returns a copy of src, replacing matches of the [Regexp]
  /// with the replacement string repl. The replacement repl is substituted directly,
  /// without using [Regexp.Expand].
  fn ReplaceAllLiteralString(self: Ref<Regexp>, src: string, repl: string) -> string

  /// ReplaceAllString returns a copy of src, replacing matches of the [Regexp]
  /// with the replacement string repl.
  /// Inside repl, $ signs are interpreted as in [Regexp.Expand].
  fn ReplaceAllString(self: Ref<Regexp>, src: string, repl: string) -> string

  /// ReplaceAllStringFunc returns a copy of src in which all matches of the
  /// [Regexp] have been replaced by the return value of function repl applied
  /// to the matched substring. The replacement returned by repl is substituted
  /// directly, without using [Regexp.Expand].
  fn ReplaceAllStringFunc(
    self: Ref<Regexp>,
    src: string,
    repl: fn(string) -> string,
  ) -> string

  /// Split slices s into substrings separated by the expression and returns a slice of
  /// the substrings between those expression matches.
  /// 
  /// The slice returned by this method consists of all the substrings of s
  /// not contained in the slice returned by [Regexp.FindAllString]. When called on an expression
  /// that contains no metacharacters, it is equivalent to [strings.SplitN].
  /// 
  /// Example:
  /// 
  /// 	s := regexp.MustCompile("a*").Split("abaabaccadaaae", 5)
  /// 	// s: ["", "b", "b", "c", "cadaaae"]
  /// 
  /// The count determines the number of substrings to return:
  ///   - n > 0: at most n substrings; the last substring will be the unsplit remainder;
  ///   - n == 0: the result is nil (zero substrings);
  ///   - n < 0: all substrings.
  fn Split(self: Ref<Regexp>, s: string, n: int) -> Slice<string>

  /// String returns the source text used to compile the regular expression.
  fn String(self: Ref<Regexp>) -> string

  /// SubexpIndex returns the index of the first subexpression with the given name,
  /// or -1 if there is no subexpression with that name.
  /// 
  /// Note that multiple subexpressions can be written using the same name, as in
  /// (?P<bob>a+)(?P<bob>b+), which declares two subexpressions named "bob".
  /// In this case, SubexpIndex returns the index of the leftmost such subexpression
  /// in the regular expression.
  fn SubexpIndex(self: Ref<Regexp>, name: string) -> int

  /// SubexpNames returns the names of the parenthesized subexpressions
  /// in this [Regexp]. The name for the first sub-expression is names[1],
  /// so that if m is a match slice, the name for m[i] is SubexpNames()[i].
  /// Since the Regexp as a whole cannot be named, names[0] is always
  /// the empty string. The slice should not be modified.
  fn SubexpNames(self: Ref<Regexp>) -> Slice<string>

  /// UnmarshalText implements [encoding.TextUnmarshaler] by calling
  /// [Compile] on the encoded value.
  fn UnmarshalText(self: Ref<Regexp>, text: Slice<uint8>) -> Result<(), error>
}
