/**
 * This module provides utility functions and type class instances for working with the `string` type in TypeScript.
 * It includes functions for basic string manipulation, as well as type class instances for
 * `Equivalence`, `Order`, `Semigroup`, and `Monoid`.
 *
 * @since 1.0.0
 */
import type { Refinement } from "@fp-ts/core/Predicate";
import type { NonEmptyReadonlyArray } from "@fp-ts/core/ReadonlyArray";
import * as equivalence from "@fp-ts/core/typeclass/Equivalence";
import * as monoid from "@fp-ts/core/typeclass/Monoid";
import * as order from "@fp-ts/core/typeclass/Order";
import * as semigroup from "@fp-ts/core/typeclass/Semigroup";
/**
 * Tests if a value is a `string`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isString } from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(isString("a"), true)
 * assert.deepStrictEqual(isString(1), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isString: Refinement<unknown, string>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Equivalence: equivalence.Equivalence<string>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Order: order.Order<string>;
/**
 * `string` semigroup under concatenation.
 *
 * @category instances
 * @since 1.0.0
 */
export declare const Semigroup: semigroup.Semigroup<string>;
/**
 * `string` monoid under concatenation.
 *
 * The `empty` value is `''`.
 *
 * @category instances
 * @since 1.0.0
 */
export declare const Monoid: monoid.Monoid<string>;
/**
 * @since 1.0.0
 */
export declare const empty: "";
/**
 * @since 1.0.0
 */
export declare const concat: {
    (that: string): (self: string) => string;
    (self: string, that: string): string;
};
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 * import { pipe } from '@fp-ts/core/Function'
 *
 * assert.deepStrictEqual(pipe('a', S.toUpperCase), 'A')
 *
 * @since 1.0.0
 */
export declare const toUpperCase: (self: string) => string;
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 * import { pipe } from '@fp-ts/core/Function'
 *
 * assert.deepStrictEqual(pipe('A', S.toLowerCase), 'a')
 *
 * @since 1.0.0
 */
export declare const toLowerCase: (self: string) => string;
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 * import { pipe } from '@fp-ts/core/Function'
 *
 * assert.deepStrictEqual(pipe('abc', S.replace('b', 'd')), 'adc')
 *
 * @since 1.0.0
 */
export declare const replace: {
    (searchValue: string | RegExp, replaceValue: string): (self: string) => string;
    (self: string, searchValue: string | RegExp, replaceValue: string): string;
};
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.trim(' a '), 'a')
 *
 * @since 1.0.0
 */
export declare const trim: (self: string) => string;
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.trimStart(' a '), 'a ')
 *
 * @since 1.0.0
 */
export declare const trimStart: (self: string) => string;
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.trimEnd(' a '), ' a')
 *
 * @since 1.0.0
 */
export declare const trimEnd: (self: string) => string;
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 * import { pipe } from '@fp-ts/core/Function'
 *
 * assert.deepStrictEqual(pipe('abcd', S.slice(1, 3)), 'bc')
 *
 * @since 1.0.0
 */
export declare const slice: {
    (start: number, end: number): (self: string) => string;
    (self: string, start: number, end: number): string;
};
/**
 * Test whether a `string` is empty.
 *
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.isEmpty(''), true)
 * assert.deepStrictEqual(S.isEmpty('a'), false)
 *
 * @since 1.0.0
 */
export declare const isEmpty: (self: string) => self is "";
/**
 * Test whether a `string` is non empty.
 *
 * @since 1.0.0
 */
export declare const isNonEmpty: (self: string) => boolean;
/**
 * Calculate the number of characters in a `string`.
 *
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.length('abc'), 3)
 *
 * @since 1.0.0
 */
export declare const length: (self: string) => number;
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 * import { pipe } from '@fp-ts/core/Function'
 *
 * assert.deepStrictEqual(pipe('abc', S.split('')), ['a', 'b', 'c'])
 * assert.deepStrictEqual(pipe('', S.split('')), [''])
 *
 * @since 1.0.0
 */
export declare const split: {
    (separator: string | RegExp): (self: string) => NonEmptyReadonlyArray<string>;
    (self: string, separator: string | RegExp): NonEmptyReadonlyArray<string>;
};
/**
 * Returns `true` if `searchString` appears as a substring of `self`, at one or more positions that are
 * greater than or equal to `0`; otherwise, returns `false`.
 *
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.includes("abc", "b"), true)
 * assert.deepStrictEqual(S.includes("abc", "d"), false)
 *
 * @since 1.0.0
 */
export declare const includes: {
    (searchString: string): (self: string) => boolean;
    (self: string, searchString: string): boolean;
};
/**
 * Returns `true` if `searchString` appears as a substring of `self`, at one or more positions that are
 * greater than or equal to `position`; otherwise, returns `false`.
 *
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.includesWithPosition("abc", "b", 1), true)
 * assert.deepStrictEqual(S.includesWithPosition("abc", "a", 1), false)
 *
 * @since 1.0.0
 */
export declare const includesWithPosition: {
    (searchString: string, position: number): (self: string) => boolean;
    (self: string, searchString: string, position: number): boolean;
};
/**
 * Returns `true` if the sequence of elements of `searchString` is the
 * same as the corresponding elements of `s` starting at
 * position. Otherwise returns false.
 *
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.startsWith("abc", "a"), true)
 * assert.deepStrictEqual(S.startsWith("bc", "a"), false)
 *
 * @since 1.0.0
 */
export declare const startsWith: {
    (searchString: string): (self: string) => boolean;
    (self: string, searchString: string): boolean;
};
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.startsWithPosition("abc", "b", 1), true)
 * assert.deepStrictEqual(S.startsWithPosition("bc", "a", 1), false)
 *
 * @since 1.0.0
 */
export declare const startsWithPosition: {
    (searchString: string, position: number): (self: string) => boolean;
    (self: string, searchString: string, position: number): boolean;
};
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.endsWith("abc", "c"), true)
 * assert.deepStrictEqual(S.endsWith("ab", "c"), false)
 *
 * @since 1.0.0
 */
export declare const endsWith: {
    (searchString: string): (self: string) => boolean;
    (self: string, searchString: string): boolean;
};
/**
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.endsWithPosition("abc", "b", 2), true)
 * assert.deepStrictEqual(S.endsWithPosition("abc", "c", 2), false)
 *
 * @since 1.0.0
 */
export declare const endsWithPosition: {
    (searchString: string, position: number): (self: string) => boolean;
    (self: string, searchString: string, position: number): boolean;
};
/**
 * Keep the specified number of characters from the start of a string.
 *
 * If `n` is larger than the available number of characters, the string will
 * be returned whole.
 *
 * If `n` is not a positive number, an empty string will be returned.
 *
 * If `n` is a float, it will be rounded down to the nearest integer.
 *
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.takeLeft("Hello World", 5), "Hello")
 *
 * @since 1.0.0
 */
export declare const takeLeft: {
    (n: number): (self: string) => string;
    (self: string, n: number): string;
};
/**
 * Keep the specified number of characters from the end of a string.
 *
 * If `n` is larger than the available number of characters, the string will
 * be returned whole.
 *
 * If `n` is not a positive number, an empty string will be returned.
 *
 * If `n` is a float, it will be rounded down to the nearest integer.
 *
 * @example
 * import * as S from '@fp-ts/core/String'
 *
 * assert.deepStrictEqual(S.takeRight("Hello World", 5), "World")
 *
 * @since 1.0.0
 */
export declare const takeRight: {
    (n: number): (self: string) => string;
    (self: string, n: number): string;
};
//# sourceMappingURL=String.d.ts.map