import type { Falsy, IsCamelCase, IsCapitalized, IsKebabCase, IsPascalCase, IsSnakeCase, Truthy } from '@toolbox-ts/types/defs/string';
import { assertIsString, assertIsStringCamelCase, assertIsStringCapitalized, assertIsStringFalsy, assertIsStringKebabCase, assertIsStringPascalCase, assertIsStringPunctuated, assertIsStringSemver, assertIsStringSnakeCase, assertIsStringTruthy } from '../../../core/guards/primitives/strs/index.js';
export declare const is: {
    /** @narrows `string` */
    readonly any: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<string, []>, "String">;
    /** @narrows {@link IsCamelCase} */
    readonly camelCase: {
        readonly name: "isStringCaseCamel";
        readonly typeName: "StringCaseCamel";
    } & (<S extends string>(v: S) => v is IsCamelCase<S>);
    /** @narrows {@link IsCapitalized} */
    readonly capitalized: {
        readonly name: "isStringCapitalized";
        readonly typeName: "StringCapitalized";
    } & (<S extends string = string>(v: unknown) => v is IsCapitalized<S>);
    /** @narrows {@link Falsy} */
    readonly falsy: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Falsy, []>, "StringFalsy">;
    /** @narrows {@link IsKebabCase} */
    readonly kebabCase: {
        readonly name: "isStringCaseKebab";
        readonly typeName: "StringCaseKebab";
    } & (<V extends string>(v: V) => v is IsKebabCase<V>);
    /** @narrows {@link IsPascalCase} */
    readonly pascalCase: {
        readonly name: "isStringCasePascal";
        readonly typeName: "StringCasePascal";
    } & (<S extends string>(v: S) => v is IsPascalCase<S>);
    /** @narrows {@link IsSnakeCase} */
    readonly snakeCase: {
        readonly name: "isStringCaseSnake";
        readonly typeName: "StringCaseSnake";
    } & (<S extends string>(v: S) => v is IsSnakeCase<S>);
    /** @narrows {@link Truthy} */
    readonly truthy: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Truthy, []>, "StringTruthy">;
};
export declare const assert: {
    /** @asserts `string` */
    readonly any: typeof assertIsString;
    /** @asserts {@link IsCamelCase} */
    readonly camelCase: typeof assertIsStringCamelCase;
    /** @asserts {@link IsCapitalized} */
    readonly capitalized: typeof assertIsStringCapitalized;
    /** @asserts {@link Falsy} */
    readonly falsy: typeof assertIsStringFalsy;
    /** @asserts {@link IsKebabCase} */
    readonly kebabCase: typeof assertIsStringKebabCase;
    /** @asserts {@link IsPascalCase} */
    readonly pascalCase: typeof assertIsStringPascalCase;
    /** @asserts {@link IsSnakeCase} */
    readonly stringPunctuated: typeof assertIsStringPunctuated;
    /** @asserts a string is punctuated. */
    readonly stringSemVer: typeof assertIsStringSemver;
    /** @asserts a string is a valid semantic version (semver) */
    readonly snakeCase: typeof assertIsStringSnakeCase;
    /** @asserts {@link Truthy} */
    readonly truthy: typeof assertIsStringTruthy;
};
export declare const check: {
    /** @checks `string` */
    readonly any: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "String">;
    /** @checks {@link IsCamelCase} */
    readonly camelCase: never;
    /** @checks {@link Falsy} */
    readonly falsy: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "StringFalsy">;
    /** @checks {@link IsKebabCase} */
    readonly kebabCase: never;
    /** @checks {@link IsPascalCase} */
    readonly pascalCase: never;
    /** @checks {@link IsSnakeCase} */
    readonly snakeCase: never;
    /** @checks {@link Truthy} */
    readonly truthy: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "StringTruthy">;
    /** @checks {@link IsCapitalized} */
    readonly capitalized: {
        readonly name: "checkIsStringCapitalized";
        readonly typeName: "StringCapitalized";
    } & ((v: unknown) => boolean);
    /** @checks if string is punctuated. */
    readonly punctuated: {
        readonly typeName: "StringPunctuated";
        readonly name: "checkIsStringPunctuated";
    } & ((v: unknown) => boolean);
    /** @checks if string is a valid semantic version (semver) */
    readonly semver: {
        readonly typeName: "StringSemVer";
        readonly name: "checkIsStringSemVer";
    } & ((v: unknown) => boolean);
};