import { CharAt, CountInString, EndsWith, Includes, IndexOf, LeftOf, MakeEndsWith, MakeStartsWith, MidOf, PadStart, RemovePrefix, Replace, ReplaceOne, RightOf, StartsWith, Substring, Trim, Truncate } from '../types/String';
import { List } from 'ts-toolbelt/out/List/List';
import { Join } from 'ts-toolbelt/out/String/Join';
import { Split } from 'ts-toolbelt/out/String/Split';
import { Literal } from 'ts-toolbelt/out/String/_Internal';
import { Mutable } from 'utility-types';
/**
 * replaces the first occurrence of `find` with `replace`
 */
export declare const replaceOne: <Str extends string, Find extends string, ReplaceWithString extends string>(str: Str, find: Find, replace: ReplaceWithString) => ReplaceOne<Str, Find, ReplaceWithString>;
/**
 * replaces all occurrences of `find` in the given string with `replace`
 */
export declare const replaceAll: <Str extends string, Find extends string, ReplaceWithString extends string>(str: Str, find: Find, replace: ReplaceWithString) => Replace<Str, Find, ReplaceWithString>;
/**
 * better version of {@link String.prototype.match} that doesn't allow for empty match arrays
 *
 * useful when using the `noUncheckedIndexedAccess` compiler option
 * @see https://github.com/microsoft/TypeScript/issues/42296
 */
export declare const match: (str: string, regex: RegExp) => (RegExpMatchArray & [string]) | null;
/**
 * gets the character at the given `index` at compiletime
 */
export declare const charAt: <T extends string, I extends number>(string: T, index: I) => CharAt<T, I>;
/**
 * does {@link String.substring} but at compiletime
 */
export declare const substring: <Str extends string, StartIndex extends number, EndIndex extends number>(string: Str, start: StartIndex, end: EndIndex) => Substring<Str, StartIndex, EndIndex>;
/**
 * concatenates strings while keeping their values known at compiletime
 * @example
 * const foo = concatenate('foo', 'bar', 'baz') //'foobarbaz'
 */
export declare const concatenate: <T extends string[]>(...strings: T) => Join<T, "">;
/**
 * joins a string by the given `delimiter` at compiletime
 */
export declare const join: <const T extends List<Literal>, D extends string>(items: T, delimiter: D) => Join<Mutable<T>, D>;
/**
 * splits a string by the given `delimiter` at compiletime
 */
export declare const split: <T extends string, D extends string>(string: T, delimiter: D) => Split<T, D>;
/**
 * does {@link String.indexOf} but at compiletime
 */
export declare const indexOf: <Str extends string, Substring_1 extends string>(string: Str, substring: Substring_1) => IndexOf<Str, Substring_1>;
/**
 * does {@link String.includes} but at compiletime
 */
export declare const includes: <Str extends string, Substring_1 extends string>(string: Str, substring: Substring_1) => Includes<Str, Substring_1>;
/**
 * does {@link String.padStart} at compiletime
 */
export declare const padStart: <Str extends string, Size extends number, PadString extends string = " ">(string: Str, length: Size, padString?: PadString | undefined) => PadStart<Str, Size, PadString>;
/**
 * {@link String.startsWith} at compile-time
 */
export declare const startsWith: <Full extends string, CheckStart extends string>(full: Full, checkStart: CheckStart) => StartsWith<Full, CheckStart>;
/**
 * {@link String.endsWith} at compile-time
 */
export declare const endsWith: <Full extends string, CheckEnd extends string>(full: Full, checkEnd: CheckEnd) => EndsWith<Full, CheckEnd>;
declare const defaultEllipsis = "\u2026";
/**
 * truncates a string to the specified `maxLength`, concatenating an `ellipsis` if the string is too long.
 * values are preserved at compiletime where possible
 * @example
 * const foo = truncate('foobarbaz', 4) // 'foo…'
 * const bar = truncate('foobarbaz', 4, '--') // 'fo--'
 */
export declare const truncate: {
    <Str extends string, MaxLength extends number, Ellipsis extends string = typeof defaultEllipsis>(string: Str, maxLength: MaxLength, ellipsis: Ellipsis): Truncate<Str, MaxLength, Ellipsis>;
    <Str extends string, MaxLength extends number>(string: Str, maxLength: MaxLength): Truncate<Str, MaxLength>;
};
/**
 * if the given `str` doesn't already start with the given `prefix`, then append the prefix to the start of the string.
 *
 * if the `str` already starts with the `prefix`, then returns the string as is
 * @example
 * makeStartsWith('foo', '.') // '.foo'
 * makeStartsWith('.foo', '.') // '.foo'
 */
export declare const makeStartsWith: <Str extends string, Prefix extends string>(str: Str, prefix: Prefix) => MakeStartsWith<Str, Prefix>;
/**
 * if the given `str` doesn't already end with the given `suffix`, then append the suffix to the end of the string.
 *
 * if the `str` already ends with the `suffix`, then returns the string as is
 * @example
 * makeEndsWith('foo', '.') // 'foo.'
 * makeEndsWith('foo.', '.') // 'foo.'
 */
export declare const makeEndsWith: <Str extends string, Suffix extends string>(str: Str, suffix: Suffix) => MakeEndsWith<Str, Suffix>;
/**
 * gets the string to the left of the given `substring`
 * @example
 * leftOf('foo.bar', '.') //'foo'
 */
export declare const leftOf: <Str extends string, Substring_1 extends string>(str: Str, substring: Substring_1) => LeftOf<Str, Substring_1>;
/**
 * gets the string to the right of the given `substring`
 * @example
 * rightOf('foo.bar', '.') //'bar'
 */
export declare const rightOf: <Str extends string, Substring_1 extends string>(str: Str, substring: Substring_1) => RightOf<Str, Substring_1>;
/**
 * gets the string between the given `start` and `end` strings
 * @example
 * midOf('foo(bar)baz', '(', ')') //'bar'
 */
export declare const midOf: <Str extends string, Start extends string, End extends string>(str: Str, start: Start, end: End) => MidOf<Str, Start, End>;
/**
 * counts how many instances of the given `substring` are in `str`
 * @example
 * countInString('1,2,3,4', ',') //3
 */
export declare const countInString: <Str extends string, Substring_1 extends string>(str: Str, substring: Substring_1) => CountInString<Str, Substring_1>;
/** wrapper for {@link String.toLowerCase} that returns a {@link Lowercase} of the given `value` */
export declare const toLowerCase: <T extends string>(value: T) => Lowercase<T>;
/** wrapper for {@link String.toUpperCase} that returns a {@link Uppercase} of the given `value` */
export declare const toUpperCase: <T extends string>(value: T) => Uppercase<T>;
/** converts the first character of a string to uppercase */
export declare const capitalize: <T extends string>(value: T) => Capitalize<T>;
/** converts the first character of a string to lowercase */
export declare const uncapitalize: <T extends string>(value: T) => Uncapitalize<T>;
/** does {@link String.trim} at compiletime */
export declare const trim: <T extends string>(value: T) => Trim<T>;
/**
 * removes the specified `prefix` from `value` if it starts with `prefix`. otherwise returns the `value` as is
 */
export declare const removePrefix: <T extends string, Prefix extends string>(value: T, prefix: Prefix) => RemovePrefix<T, Prefix>;
export {};
//# sourceMappingURL=String.d.ts.map