import type { Fn } from '@toolbox-ts/types';
import type { CheckGuard, CheckNotGuard, ExclusiveTypeGuard, IsGuard, IsNotGuard, TypeGuard } from '@toolbox-ts/types/defs/function';
export declare const createNames: <N extends string>(typeName: N) => {
    check: `checkIs${Capitalize<N>}`;
    is: `is${Capitalize<N>}`;
    type: Capitalize<N>;
};
export declare const createTypeNames: <D extends string, N extends string>(domain: D, names: N[]) => { [K in N]: `${Capitalize<D>}${Capitalize<K>}`; } & {
    _: D;
};
export declare const createGuard: <Name extends string, TypeName extends string, F extends Fn.Any>(name: Name, typeName: TypeName, fn: F) => {
    readonly name: Name;
    readonly typeName: TypeName;
} & F;
export declare const createCheckGuard: <TypeName extends string, F extends Fn.CheckGuard>(typeName: TypeName, fn: F) => {
    readonly typeName: Capitalize<TypeName>;
    readonly name: `checkIs${Capitalize<TypeName>}`;
} & F;
export declare const createGenericIsGuards: <TypeName extends string, F extends Fn.Any>(typeName: TypeName, fn: F) => {
    is: {
        readonly name: `is${Capitalize<TypeName>}`;
        readonly typeName: TypeName;
    } & F;
    check: {
        readonly name: `checkIs${Capitalize<TypeName>}`;
        readonly typeName: TypeName;
    } & (F extends (v: unknown, ...args: infer A) => v is unknown ? (v: unknown, ...args: A) => boolean : never);
};
export type IsGuardPair<N extends string, V = unknown, A extends unknown[] = void[]> = {
    is: TypeGuard<IsGuard<V, A>, N>;
    check: TypeGuard<CheckGuard<A>, N>;
};
/**
 * Creates a pair of type guards: `isX` and `checkIsX`.
 *
 * @param name - The base name for the type guards.
 * @param is - The implementation of the `isX` guard.
 * @returns An object containing the `isX` and `checkIsX` guards.
 *
 * @example
 * ```ts
 * const { isString, checkIsString } = createIsGuards('string', (v): v is string => typeof v === 'string');
 *
 * isString('hello'); // true
 * checkIsString(123); // false
 * ```
 */
export declare function createIsGuards<Name extends string, T, A extends unknown[] = void[]>(name: Name, is: IsGuard<T, A>): IsGuardPair<Name, T, A>;
export type NotGuardPair<N extends string, T, A extends unknown[] = void[]> = {
    not: ExclusiveTypeGuard<IsNotGuard<T, A>, N>;
    checkNot: ExclusiveTypeGuard<CheckNotGuard<A>, N>;
};
/**
 * Creates a pair of negated type guards: `isNotX` and `checkIsNotX`.
 *
 * @param name - The base name for the type guards. Exclude the "Not" prefix, it is added automatically.
 * @param isNot - The implementation of the `isNotX` guard.
 * @returns An object containing the `isNotX` and `checkIsNotX` guards.
 * @example
 * ```ts
 * const { isNotString, checkIsNotString } = createIsNotGuards('string', (v): v is not string => typeof v !== 'string');
 *
 * isNotString(123); // true
 * checkIsNotString('hello'); // false
 * ```
 *
 */
export declare function createIsNotGuards<Name extends string, T, A extends unknown[] = void[]>(name: Name, isNot: <V>(v: V, ...args: A) => v is Exclude<V, T>): NotGuardPair<Name, T, A>;
export declare const createIsAndIsNotGuards: <Name extends string, T, A extends unknown[] = void[]>(name: Name, is: IsGuard<T, A>, isNot?: IsNotGuard<T, A>) => NotGuardPair<Name, T, A> & IsGuardPair<Name, T, A>;