import { z } from 'zod';
/**
 * Marks a Zod schema to prevent case conversion of its keys and nested content.
 * Use this for schemas where keys are semantic values (like OPC UA NodeIds or Modbus channel keys)
 * rather than property names.
 *
 * @param schema - The Zod schema to mark
 * @returns The same schema with a preserve case marker
 *
 * @example
 * const propertiesZ = z.object({
 *   read: z.object({
 *     channels: preserveCase(z.record(z.string(), z.number()))
 *   })
 * });
 */
export declare const preserveCase: <T extends z.ZodType>(schema: T) => T;
/**
 * SnakeToCamel converts the given value from snake_case to camelCase. Note that this
 * function will ONLY convert snake_case, not any other case. For example, a value
 * like "foo-bar" will not be converted to "foo_bar". It will also not alter the
 * capitalization of the first character.
 *
 * @param value - A string, object, array of objects, or array of strings whose case
 * needs to be converted.
 * @returns A copy of the value with the case converted.
 */
export declare const snakeToCamel: <V>(obj: V, opt?: Options) => V;
/**
 * Converts a camelCase string to snake_case.
 *
 * @param str - The string to convert
 * @returns The converted string in snake_case
 */
export declare const camelToSnake: <V>(obj: V, opt?: Options) => V;
/**
 * Capitalize capitalizes the first character of the given string.
 *
 * @param str - The string to capitalize.
 * @returns The string with the first character capitalized.
 */
export declare const capitalize: (str: string) => string;
/**
 * Options parameter for convert function
 *
 * @param recursive: recursive if value of subkey is an object that is not an array
 * @param recursiveInArray: recursive if ${recursive} is `true` and value of subkey
 * is an array. All elements in array (value of subkey) will be recursive.
 * If ${recursiveInArray} is not set, default is `false`.
 * @param keepTypesOnRecursion: list of types will be keep value on recursion.
 * Example Date, RegExp. These types will be right-hand side of 'instanceof' operator.
 */
export interface Options {
    recursive?: boolean;
    recursiveInArray?: boolean;
    schema?: z.ZodType;
}
/**
 * Converts a string to kebab-case.
 * Handles spaces, camelCase, and uppercase characters.
 *
 * @param str - The string to convert
 * @returns The converted string in kebab-case
 */
export declare const toKebab: <V>(obj: V, opt?: Options) => V;
/**
 * Converts a string to proper noun format.
 * Handles snake_case, kebab-case, camelCase, and PascalCase.
 * Each word is capitalized.
 *
 * @param str - The string to convert
 * @returns The converted string in proper noun format
 */
export declare const toProperNoun: <V>(obj: V, opt?: Options) => V;
//# sourceMappingURL=caseconv.d.ts.map