func contains(s: string; pattern: Regex): bool {....raises: [],
    deprecated: "use contains(string, Regex2) instead", tags: [RootEffect].}

func endsWith(s: string; pattern: Regex): bool {....raises: [],
    deprecated: "use endsWith(string, Regex2) instead", tags: [RootEffect].}

func find(s: string; pattern: Regex; m: var RegexMatch; start = 0): bool {.
    ...raises: [], deprecated: "use find(string, Regex2, var RegexMatch2) instead",
    tags: [RootEffect].}

func findAll(s: string; pattern: Regex; start = 0): seq[RegexMatch] {.
    ...raises: [], deprecated: "use findAll(string, Regex2) instead",
    tags: [RootEffect].}

func findAllBounds(s: string; pattern: Regex; start = 0): seq[Slice[int]] {.
    ...raises: [], deprecated: "use findAllBounds(string, Regex2) instead",
    tags: [RootEffect].}

func findAndCaptureAll(s: string; pattern: Regex): seq[string] {....raises: [],
    deprecated: "use findAll(string, Regex2) instead", tags: [RootEffect].}

func group(m: RegexMatch; groupName: string; text: string): seq[string] {.
    inline, ...raises: [KeyError], deprecated, tags: [].}

func group(m: RegexMatch; i: int): seq[Slice[int]] {.inline, ...raises: [],
    deprecated: "use group(RegexMatch2, int)", tags: [].}

func group(m: RegexMatch; i: int; text: string): seq[string] {.inline,
    ...raises: [], deprecated, tags: [].}

func group(m: RegexMatch; s: string): seq[Slice[int]] {.inline,
    ...raises: [KeyError], deprecated: "use group(RegexMatch2, string)", tags: [].}

func groupFirstCapture(m: RegexMatch; groupName: string; text: string): string {.
    inline, ...raises: [KeyError], deprecated, tags: [].}

func groupFirstCapture(m: RegexMatch; i: int; text: string): string {.inline,
    ...raises: [], deprecated, tags: [].}

func groupLastCapture(m: RegexMatch; groupName: string; text: string): string {.
    inline, ...raises: [KeyError],
    deprecated: "use group(RegexMatch2, string) instead", tags: [].}

func groupLastCapture(m: RegexMatch; i: int; text: string): string {.inline,
    ...raises: [], deprecated: "use group(RegexMatch2, int) instead", tags: [].}

func groupNames(m: RegexMatch): seq[string] {.inline, ...raises: [],
    deprecated: "use groupNames(RegexMatch2)", tags: [].}

func groupsCount(m: RegexMatch): int {.inline, ...raises: [], deprecated: "use groupsCount(RegexMatch2)",
                                       tags: [].}

func isInitialized(re: Regex): bool {.inline, ...raises: [], deprecated: "use isInitialized(Regex2) instead",
                                      tags: [].}

func match(s: string; pattern: Regex): bool {....raises: [],
    deprecated: "use match(string, Regex2) instead", tags: [RootEffect].}

func match(s: string; pattern: Regex; m: var RegexMatch; start = 0): bool {.
    ...raises: [],
    deprecated: "use match(string, Regex2, var RegexMatch2) instead",
    tags: [RootEffect].}

func re(s: static string): static[Regex] {.
    ...deprecated: "use re2(static string) instead".}

func re(s: string): Regex {....raises: [RegexError],
                            deprecated: "use re2(string) instead", tags: [].}

func replace(s: string; pattern: Regex;
             by: proc (m: RegexMatch; s: string): string; limit = 0): string {.
    ...raises: [], effectsOf: by, ...deprecated: "use replace(string, Regex2, proc(RegexMatch2, string): string) instead",
    tags: [RootEffect].}

func replace(s: string; pattern: Regex; by: string; limit = 0): string {.
    ...raises: [ValueError],
    deprecated: "use replace(string, Regex2, string) instead",
    tags: [RootEffect].}

func split(s: string; sep: Regex): seq[string] {....raises: [],
    deprecated: "use split(string, Regex2) instead", tags: [RootEffect].}

func splitIncl(s: string; sep: Regex): seq[string] {....raises: [],
    deprecated: "use splitIncl(string, Regex2) instead", tags: [RootEffect].}

func startsWith(s: string; pattern: Regex; start = 0): bool {....raises: [],
    deprecated: "use startsWith(string, Regex2) instead", tags: [RootEffect].}

func toPattern(s: string): Regex {....raises: [RegexError],
                                   deprecated: "Use `re2(string)` instead",
                                   tags: [].}

iterator findAll(s: string; pattern: Regex; start = 0): RegexMatch {.inline,
    ...raises: [], deprecated: "use findAll(string, Regex2) instead",
    tags: [RootEffect].}

iterator findAllBounds(s: string; pattern: Regex; start = 0): Slice[int] {.
    inline, ...raises: [], deprecated: "use findAllBounds(string, Regex2) instead",
    tags: [RootEffect].}

iterator group(m: RegexMatch; i: int): Slice[int] {.inline, ...raises: [],
    deprecated, tags: [].}

iterator group(m: RegexMatch; s: string): Slice[int] {.inline,
    ...raises: [KeyError], deprecated, tags: [].}

iterator split(s: string; sep: Regex): string {.inline, ...raises: [],
    deprecated: "use split(string, Regex2) instead", tags: [RootEffect].}