import type { CamelToKebab, CamelToPascal, KebabToCamel, KebabToPascal, KebabToSnake, PascalToCamel, PascalToKebab, PascalToSnake, SnakeToCamel, SnakeToKebab, SnakeToPascal } from '@toolbox-ts/types/defs/string';
import { assertIsStringCamelCase, assertIsStringKebabCase, assertIsStringPascalCase, assertIsStringSnakeCase } from '../../../../core/guards/primitives/strs/index.js';
export declare const camel: {
    readonly is: {
        readonly name: "isStringCaseCamel";
        readonly typeName: "StringCaseCamel";
    } & (<S extends string>(v: S) => v is import("@toolbox-ts/types/defs/string").IsCamelCase<S>);
    readonly assert: typeof assertIsStringCamelCase;
    /**
     * Basic camel to kebab text conversion
     * - Ensures the first letter is lowercase.
     * - Separates uppercase letters and prefixes with hyphen
     *  - This behavior is chosen to align the result with the CamelToKebab Type.
     * - Converts full string to lowercase.
     * @example
     * ```ts
     * camelToKebab('noEdit')                 // 'no-edit'
     * camelToKebab('helloWorldHowAreYou')    // 'hello-world-how-are-you-doing-today'
     * camelToKebab('aAAAAA')                 // 'a-a-a-a-a-a'
     * ```
     */
    readonly toKebab: <S extends string>(str: S) => CamelToKebab<S>;
    /**
     * Converts a camelCase string to PascalCase.
     *
     * @template S - The camelCase string to convert.
     * @example
     * ```ts
     * camel.toPascal('camelCase') // 'CamelCase'
     * camel.toPascal('helloWorld') // 'HelloWorld'
     * ```
     */
    readonly toPascal: <S extends string>(s: S) => CamelToPascal<S>;
    /**
     * Converts a camelCase string to snake_case.
     *
     * @example
     * ```ts
     * camel.toSnake('camelCase') // 'camel_case'
     * camel.toSnake('helloWorld') // 'hello_world'
     * ```
     */
    readonly toSnake: <S extends string>(str: S) => KebabToSnake<CamelToKebab<S>>;
};
export declare const pascal: {
    readonly is: {
        readonly name: "isStringCasePascal";
        readonly typeName: "StringCasePascal";
    } & (<S extends string>(v: S) => v is import("@toolbox-ts/types/defs/string").IsPascalCase<S>);
    readonly assert: typeof assertIsStringPascalCase;
    /**
     * Converts a PascalCase string to kebab-case.
     *
     * @example
     * ```ts
     * pascal.toKebab('PascalCase') // 'pascal-case'
     * pascal.toKebab('HelloWorld') // 'hello-world'
     * ```
     */
    readonly toKebab: <S extends string>(str: S) => PascalToKebab<S>;
    /**
     * Converts a PascalCase string to camelCase.
     *
     * @example
     * ```ts
     * pascal.toCamel('PascalCase') // 'pascalCase'
     * pascal.toCamel('HelloWorld') // 'helloWorld'
     * ```
     */
    readonly toCamel: <S extends string>(s: S) => PascalToCamel<S>;
    /**
     * Converts a PascalCase string to snake_case.
     *
     * @example
     * ```ts
     * pascal.toSnake('PascalCase') // 'pascal_case'
     * pascal.toSnake('HelloWorld') // 'hello_world'
     * ```
     */
    readonly toSnake: <S extends string>(str: S) => PascalToSnake<S>;
};
export declare const kebab: {
    readonly is: {
        readonly name: "isStringCaseKebab";
        readonly typeName: "StringCaseKebab";
    } & (<V extends string>(v: V) => v is import("@toolbox-ts/types/defs/string").IsKebabCase<V>);
    readonly assert: typeof assertIsStringKebabCase;
    /**
     * Converts a kebab-case string to camelCase.
     * @example
     * ```ts
     * kebab.toCamel('node-edit')        // 'noEdit'
     * kebab.toCamel('no-verify')        // 'noVerify'
     * kebab.toCamel('a-a-a-a-a-a')      // 'aAAAAA'
     * ```
     */
    readonly toCamel: <S extends string>(str: S) => KebabToCamel<S>;
    /**
     * Converts a kebab-case string to PascalCase.
     * @example
     * ```ts
     * kebab.toPascal('node-edit')        // 'NoEdit'
     * kebab.toPascal('no-verify')        // 'NoVerify'
     * kebab.toPascal('a-a-a-a-a-a')      // 'AAAAAA'
     * ```
     */
    readonly toPascal: <S extends string>(str: S) => KebabToPascal<S>;
    /**
     * Converts a kebab-case string to snake_case.
     *
     * @example
     * ```ts
     * kebab.toSnake('kebab-case') // 'kebab_case'
     * kebab.toSnake('no-verify')  // 'no_verify'
     * ```
     */
    readonly toSnake: <S extends string>(str: S) => KebabToSnake<S>;
};
export declare const snake: {
    readonly is: {
        readonly name: "isStringCaseSnake";
        readonly typeName: "StringCaseSnake";
    } & (<S extends string>(v: S) => v is import("@toolbox-ts/types/defs/string").IsSnakeCase<S>);
    readonly assert: typeof assertIsStringSnakeCase;
    /**
     * Converts a snake_case string to kebab-case.
     * @example
     * ```ts
     * snake.toKebab('node_edit')        // 'node-edit'
     * snake.toKebab('no_verify')        // 'no-verify'
     * snake.toKebab('a_a_a_a_a_a')      // 'a-a-a-a-a-a'
     * ```
     */
    readonly toKebab: <S extends string>(str: S) => SnakeToKebab<S>;
    /**
     * Converts a snake_case string to camelCase.
     *
     * @example
     * ```ts
     * snake.toCamel('snake_case') // 'snakeCase'
     * snake.toCamel('no_verify')  // 'noVerify'
     * ```
     */
    readonly toCamel: <S extends string>(str: S) => SnakeToCamel<S>;
    /**
     * Converts a snake_case string to PascalCase.
     *
     * @example
     * ```ts
     * snake.toPascal('snake_case') // 'SnakeCase'
     * snake.toPascal('no_verify')  // 'NoVerify'
     * ```
     */
    readonly toPascal: <S extends string>(str: S) => SnakeToPascal<S>;
};