// Generated by Lisette bindgen
// Source: strings (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

import "go:io"
import "go:iter"
import "go:unicode"

/// Clone returns a fresh copy of s.
/// It guarantees to make a copy of s into a new allocation,
/// which can be important when retaining only a small substring
/// of a much larger string. Using Clone can help such programs
/// use less memory. Of course, since using Clone makes a copy,
/// overuse of Clone can make programs use more memory.
/// Clone should typically be used only rarely, and only when
/// profiling indicates that it is needed.
/// For strings of length zero the string "" will be returned
/// and no allocation is made.
pub fn Clone(s: string) -> string

/// Compare returns an integer comparing two strings lexicographically.
/// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
/// 
/// Use Compare when you need to perform a three-way comparison (with
/// [slices.SortFunc], for example). It is usually clearer and always faster
/// to use the built-in string comparison operators ==, <, >, and so on.
pub fn Compare(a: string, b: string) -> int

/// Contains reports whether substr is within s.
pub fn Contains(s: string, substr: string) -> bool

/// ContainsAny reports whether any Unicode code points in chars are within s.
pub fn ContainsAny(s: string, chars: string) -> bool

/// ContainsFunc reports whether any Unicode code points r within s satisfy f(r).
pub fn ContainsFunc(s: string, f: fn(rune) -> bool) -> bool

/// ContainsRune reports whether the Unicode code point r is within s.
pub fn ContainsRune(s: string, r: rune) -> bool

/// Count counts the number of non-overlapping instances of substr in s.
/// If substr is an empty string, Count returns 1 + the number of Unicode code points in s.
pub fn Count(s: string, substr: string) -> int

/// Cut slices s around the first instance of sep,
/// returning the text before and after sep.
/// The found result reports whether sep appears in s.
/// If sep does not appear in s, cut returns s, "", false.
pub fn Cut(s: string, sep: string) -> (string, string, bool)

/// CutPrefix returns s without the provided leading prefix string
/// and reports whether it found the prefix.
/// If s doesn't start with prefix, CutPrefix returns s, false.
/// If prefix is the empty string, CutPrefix returns s, true.
pub fn CutPrefix(s: string, prefix: string) -> Option<string>

/// CutSuffix returns s without the provided ending suffix string
/// and reports whether it found the suffix.
/// If s doesn't end with suffix, CutSuffix returns s, false.
/// If suffix is the empty string, CutSuffix returns s, true.
pub fn CutSuffix(s: string, suffix: string) -> Option<string>

/// EqualFold reports whether s and t, interpreted as UTF-8 strings,
/// are equal under simple Unicode case-folding, which is a more general
/// form of case-insensitivity.
pub fn EqualFold(s: string, t: string) -> bool

/// Fields splits the string s around each instance of one or more consecutive white space
/// characters, as defined by [unicode.IsSpace], returning a slice of substrings of s or an
/// empty slice if s contains only white space. Every element of the returned slice is
/// non-empty. Unlike [Split], leading and trailing runs runs of white space characters
/// are discarded.
pub fn Fields(s: string) -> Slice<string>

/// FieldsFunc splits the string s at each run of Unicode code points c satisfying f(c)
/// and returns an array of slices of s. If all code points in s satisfy f(c) or the
/// string is empty, an empty slice is returned. Every element of the returned slice is
/// non-empty. Unlike [SplitFunc], leading and trailing runs of code points satisfying f(c)
/// are discarded.
/// 
/// FieldsFunc makes no guarantees about the order in which it calls f(c)
/// and assumes that f always returns the same value for a given c.
pub fn FieldsFunc(s: string, f: fn(rune) -> bool) -> Slice<string>

/// FieldsFuncSeq returns an iterator over substrings of s split around runs of
/// Unicode code points satisfying f(c).
/// The iterator yields the same strings that would be returned by [FieldsFunc](s),
/// but without constructing the slice.
pub fn FieldsFuncSeq(s: string, f: fn(rune) -> bool) -> iter.Seq<string>

/// FieldsSeq returns an iterator over substrings of s split around runs of
/// whitespace characters, as defined by [unicode.IsSpace].
/// The iterator yields the same strings that would be returned by [Fields](s),
/// but without constructing the slice.
pub fn FieldsSeq(s: string) -> iter.Seq<string>

/// HasPrefix reports whether the string s begins with prefix.
pub fn HasPrefix(s: string, prefix: string) -> bool

/// HasSuffix reports whether the string s ends with suffix.
pub fn HasSuffix(s: string, suffix: string) -> bool

/// Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.
#[go(sentinel_minus_one)]
pub fn Index(s: string, substr: string) -> Option<int>

/// IndexAny returns the index of the first instance of any Unicode code point
/// from chars in s, or -1 if no Unicode code point from chars is present in s.
#[go(sentinel_minus_one)]
pub fn IndexAny(s: string, chars: string) -> Option<int>

/// IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.
#[go(sentinel_minus_one)]
pub fn IndexByte(s: string, c: byte) -> Option<int>

/// IndexFunc returns the index into s of the first Unicode
/// code point satisfying f(c), or -1 if none do.
#[go(sentinel_minus_one)]
pub fn IndexFunc(s: string, f: fn(rune) -> bool) -> Option<int>

/// IndexRune returns the index of the first instance of the Unicode code point
/// r, or -1 if rune is not present in s.
/// If r is [utf8.RuneError], it returns the first instance of any
/// invalid UTF-8 byte sequence.
#[go(sentinel_minus_one)]
pub fn IndexRune(s: string, r: rune) -> Option<int>

/// Join concatenates the elements of its first argument to create a single string. The separator
/// string sep is placed between elements in the resulting string.
pub fn Join(elems: Slice<string>, sep: string) -> string

/// LastIndex returns the index of the last instance of substr in s, or -1 if substr is not present in s.
#[go(sentinel_minus_one)]
pub fn LastIndex(s: string, substr: string) -> Option<int>

/// LastIndexAny returns the index of the last instance of any Unicode code
/// point from chars in s, or -1 if no Unicode code point from chars is
/// present in s.
#[go(sentinel_minus_one)]
pub fn LastIndexAny(s: string, chars: string) -> Option<int>

/// LastIndexByte returns the index of the last instance of c in s, or -1 if c is not present in s.
#[go(sentinel_minus_one)]
pub fn LastIndexByte(s: string, c: byte) -> Option<int>

/// LastIndexFunc returns the index into s of the last
/// Unicode code point satisfying f(c), or -1 if none do.
#[go(sentinel_minus_one)]
pub fn LastIndexFunc(s: string, f: fn(rune) -> bool) -> Option<int>

/// Lines returns an iterator over the newline-terminated lines in the string s.
/// The lines yielded by the iterator include their terminating newlines.
/// If s is empty, the iterator yields no lines at all.
/// If s does not end in a newline, the final yielded line will not end in a newline.
/// It returns a single-use iterator.
pub fn Lines(s: string) -> iter.Seq<string>

/// Map returns a copy of the string s with all its characters modified
/// according to the mapping function. If mapping returns a negative value, the character is
/// dropped from the string with no replacement.
pub fn Map(mapping: fn(rune) -> rune, s: string) -> string

/// NewReader returns a new [Reader] reading from s.
/// It is similar to [bytes.NewBufferString] but more efficient and non-writable.
pub fn NewReader(s: string) -> Ref<Reader>

/// NewReplacer returns a new [Replacer] from a list of old, new string
/// pairs. Replacements are performed in the order they appear in the
/// target string, without overlapping matches. The old string
/// comparisons are done in argument order.
/// 
/// NewReplacer panics if given an odd number of arguments.
pub fn NewReplacer(oldnew: VarArgs<string>) -> Ref<Replacer>

/// Repeat returns a new string consisting of count copies of the string s.
/// 
/// It panics if count is negative or if the result of (len(s) * count)
/// overflows.
pub fn Repeat(s: string, count: int) -> string

/// Replace returns a copy of the string s with the first n
/// non-overlapping instances of old replaced by new.
/// If old is empty, it matches at the beginning of the string
/// and after each UTF-8 sequence, yielding up to k+1 replacements
/// for a k-rune string.
/// If n < 0, there is no limit on the number of replacements.
pub fn Replace(s: string, old: string, new: string, n: int) -> string

/// ReplaceAll returns a copy of the string s with all
/// non-overlapping instances of old replaced by new.
/// If old is empty, it matches at the beginning of the string
/// and after each UTF-8 sequence, yielding up to k+1 replacements
/// for a k-rune string.
pub fn ReplaceAll(s: string, old: string, new: string) -> string

/// Split slices s into all substrings separated by sep and returns a slice of
/// the substrings between those separators.
/// 
/// If s does not contain sep and sep is not empty, Split returns a
/// slice of length 1 whose only element is s.
/// 
/// If sep is empty, Split splits after each UTF-8 sequence. If both s
/// and sep are empty, Split returns an empty slice.
/// 
/// It is equivalent to [SplitN] with a count of -1.
/// 
/// To split around the first instance of a separator, see [Cut].
pub fn Split(s: string, sep: string) -> Slice<string>

/// SplitAfter slices s into all substrings after each instance of sep and
/// returns a slice of those substrings.
/// 
/// If s does not contain sep and sep is not empty, SplitAfter returns
/// a slice of length 1 whose only element is s.
/// 
/// If sep is empty, SplitAfter splits after each UTF-8 sequence. If
/// both s and sep are empty, SplitAfter returns an empty slice.
/// 
/// It is equivalent to [SplitAfterN] with a count of -1.
pub fn SplitAfter(s: string, sep: string) -> Slice<string>

/// SplitAfterN slices s into substrings after each instance of sep and
/// returns a slice of those substrings.
/// 
/// 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.
/// 
/// Edge cases for s and sep (for example, empty strings) are handled
/// as described in the documentation for [SplitAfter].
pub fn SplitAfterN(s: string, sep: string, n: int) -> Slice<string>

/// SplitAfterSeq returns an iterator over substrings of s split after each instance of sep.
/// The iterator yields the same strings that would be returned by [SplitAfter](s, sep),
/// but without constructing the slice.
/// It returns a single-use iterator.
pub fn SplitAfterSeq(s: string, sep: string) -> iter.Seq<string>

/// SplitN slices s into substrings separated by sep and returns a slice of
/// the substrings between those separators.
/// 
/// 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.
/// 
/// Edge cases for s and sep (for example, empty strings) are handled
/// as described in the documentation for [Split].
/// 
/// To split around the first instance of a separator, see [Cut].
pub fn SplitN(s: string, sep: string, n: int) -> Slice<string>

/// SplitSeq returns an iterator over all substrings of s separated by sep.
/// The iterator yields the same strings that would be returned by [Split](s, sep),
/// but without constructing the slice.
/// It returns a single-use iterator.
pub fn SplitSeq(s: string, sep: string) -> iter.Seq<string>

/// Title returns a copy of the string s with all Unicode letters that begin words
/// mapped to their Unicode title case.
/// 
/// Deprecated: The rule Title uses for word boundaries does not handle Unicode
/// punctuation properly. Use golang.org/x/text/cases instead.
pub fn Title(s: string) -> string

/// ToLower returns s with all Unicode letters mapped to their lower case.
pub fn ToLower(s: string) -> string

/// ToLowerSpecial returns a copy of the string s with all Unicode letters mapped to their
/// lower case using the case mapping specified by c.
pub fn ToLowerSpecial(c: unicode.SpecialCase, s: string) -> string

/// ToTitle returns a copy of the string s with all Unicode letters mapped to
/// their Unicode title case.
pub fn ToTitle(s: string) -> string

/// ToTitleSpecial returns a copy of the string s with all Unicode letters mapped to their
/// Unicode title case, giving priority to the special casing rules.
pub fn ToTitleSpecial(c: unicode.SpecialCase, s: string) -> string

/// ToUpper returns s with all Unicode letters mapped to their upper case.
pub fn ToUpper(s: string) -> string

/// ToUpperSpecial returns a copy of the string s with all Unicode letters mapped to their
/// upper case using the case mapping specified by c.
pub fn ToUpperSpecial(c: unicode.SpecialCase, s: string) -> string

/// ToValidUTF8 returns a copy of the string s with each run of invalid UTF-8 byte sequences
/// replaced by the replacement string, which may be empty.
pub fn ToValidUTF8(s: string, replacement: string) -> string

/// Trim returns a slice of the string s with all leading and
/// trailing Unicode code points contained in cutset removed.
pub fn Trim(s: string, cutset: string) -> string

/// TrimFunc returns a slice of the string s with all leading
/// and trailing Unicode code points c satisfying f(c) removed.
pub fn TrimFunc(s: string, f: fn(rune) -> bool) -> string

/// TrimLeft returns a slice of the string s with all leading
/// Unicode code points contained in cutset removed.
/// 
/// To remove a prefix, use [TrimPrefix] instead.
pub fn TrimLeft(s: string, cutset: string) -> string

/// TrimLeftFunc returns a slice of the string s with all leading
/// Unicode code points c satisfying f(c) removed.
pub fn TrimLeftFunc(s: string, f: fn(rune) -> bool) -> string

/// TrimPrefix returns s without the provided leading prefix string.
/// If s doesn't start with prefix, s is returned unchanged.
pub fn TrimPrefix(s: string, prefix: string) -> string

/// TrimRight returns a slice of the string s, with all trailing
/// Unicode code points contained in cutset removed.
/// 
/// To remove a suffix, use [TrimSuffix] instead.
pub fn TrimRight(s: string, cutset: string) -> string

/// TrimRightFunc returns a slice of the string s with all trailing
/// Unicode code points c satisfying f(c) removed.
pub fn TrimRightFunc(s: string, f: fn(rune) -> bool) -> string

/// TrimSpace returns a slice of the string s, with all leading
/// and trailing white space removed, as defined by Unicode.
pub fn TrimSpace(s: string) -> string

/// TrimSuffix returns s without the provided trailing suffix string.
/// If s doesn't end with suffix, s is returned unchanged.
pub fn TrimSuffix(s: string, suffix: string) -> string

/// A Builder is used to efficiently build a string using [Builder.Write] methods.
/// It minimizes memory copying. The zero value is ready to use.
/// Do not copy a non-zero Builder.
pub type Builder

/// A Reader implements the [io.Reader], [io.ReaderAt], [io.ByteReader], [io.ByteScanner],
/// [io.RuneReader], [io.RuneScanner], [io.Seeker], and [io.WriterTo] interfaces by reading
/// from a string.
/// The zero value for Reader operates like a Reader of an empty string.
pub type Reader

/// Replacer replaces a list of strings with replacements.
/// It is safe for concurrent use by multiple goroutines.
pub type Replacer

impl Builder {
  /// Cap returns the capacity of the builder's underlying byte slice. It is the
  /// total space allocated for the string being built and includes any bytes
  /// already written.
  fn Cap(self: Ref<Builder>) -> int

  /// Grow grows b's capacity, if necessary, to guarantee space for
  /// another n bytes. After Grow(n), at least n bytes can be written to b
  /// without another allocation. If n is negative, Grow panics.
  fn Grow(self: Ref<Builder>, n: int)

  /// Len returns the number of accumulated bytes; b.Len() == len(b.String()).
  fn Len(self: Ref<Builder>) -> int

  /// Reset resets the [Builder] to be empty.
  fn Reset(self: Ref<Builder>)

  /// String returns the accumulated string.
  fn String(self: Ref<Builder>) -> string

  /// Write appends the contents of p to b's buffer.
  /// Write always returns len(p), nil.
  fn Write(self: Ref<Builder>, p: Slice<byte>) -> Partial<int, error>

  /// WriteByte appends the byte c to b's buffer.
  /// The returned error is always nil.
  #[allow(unused_result)]
  fn WriteByte(self: Ref<Builder>, c: byte) -> Result<(), error>

  /// WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
  /// It returns the length of r and a nil error.
  #[allow(unused_result)]
  fn WriteRune(self: Ref<Builder>, r: rune) -> Result<int, error>

  /// WriteString appends the contents of s to b's buffer.
  /// It returns the length of s and a nil error.
  #[allow(unused_partial)]
  fn WriteString(self: Ref<Builder>, s: string) -> Partial<int, error>
}

impl Reader {
  /// Len returns the number of bytes of the unread portion of the
  /// string.
  fn Len(self: Ref<Reader>) -> int

  /// Read implements the [io.Reader] interface.
  fn Read(self: Ref<Reader>, mut b: Slice<byte>) -> Partial<int, error>

  /// ReadAt implements the [io.ReaderAt] interface.
  fn ReadAt(self: Ref<Reader>, mut b: Slice<byte>, off: int64) -> Partial<int, error>

  /// ReadByte implements the [io.ByteReader] interface.
  fn ReadByte(self: Ref<Reader>) -> Result<byte, error>

  /// ReadRune implements the [io.RuneReader] interface.
  fn ReadRune(self: Ref<Reader>) -> Result<(rune, int), error>

  /// Reset resets the [Reader] to be reading from s.
  fn Reset(self: Ref<Reader>, s: string)

  /// Seek implements the [io.Seeker] interface.
  fn Seek(self: Ref<Reader>, offset: int64, whence: int) -> Result<int64, error>

  /// Size returns the original length of the underlying string.
  /// Size is the number of bytes available for reading via [Reader.ReadAt].
  /// The returned value is always the same and is not affected by calls
  /// to any other method.
  fn Size(self: Ref<Reader>) -> int64

  /// UnreadByte implements the [io.ByteScanner] interface.
  fn UnreadByte(self: Ref<Reader>) -> Result<(), error>

  /// UnreadRune implements the [io.RuneScanner] interface.
  fn UnreadRune(self: Ref<Reader>) -> Result<(), error>

  /// WriteTo implements the [io.WriterTo] interface.
  fn WriteTo(self: Ref<Reader>, w: io.Writer) -> Partial<int64, error>
}

impl Replacer {
  /// Replace returns a copy of s with all replacements performed.
  fn Replace(self: Ref<Replacer>, s: string) -> string

  /// WriteString writes s to w with all replacements performed.
  fn WriteString(self: Ref<Replacer>, w: io.Writer, s: string) -> Partial<int, error>
}
