import { CharacterArg, TextType } from '..';
import { AnyExpression, Expression } from '../../expressions';
import { ConstraintConfig } from '../../functions';
import { Type } from '../index';
import { IntegerArg } from '../math';
export declare const BIT: (n?: number | undefined) => BitType<true>;
export declare type BitArg = BitType['argument'];
export interface BitType<R extends boolean = any> extends Type<'BIT', R> {
    expression: BinaryExpression<BitType<R>>;
    argument: Expression<BitType> | this['input'] | Expression<VarbitType>;
    required(conf?: ConstraintConfig): BitType<false>;
}
export declare const VARBIT: (n?: number | undefined) => VarbitType<true>;
export declare type VarbitArg = VarbitType['argument'];
export interface VarbitType<R extends boolean = any> extends Type<'VARBIT', R> {
    expression: BinaryExpression<VarbitType<R>>;
    argument: Expression<VarbitType> | this['input'] | Expression<BitType>;
    required(conf?: ConstraintConfig): VarbitType<false>;
}
export declare type BinaryTypes = BitType | VarbitType;
export declare type BinaryArg = BinaryTypes['argument'];
export interface BinaryExpression<T extends BinaryTypes = BinaryTypes> extends AnyExpression<T> {
    concat(arg: BinaryArg): Expression<VarbitType<T['nullable']>>;
    concat(arg: CharacterArg): Expression<TextType<T['nullable']>>;
    and(arg: BinaryArg): Expression<BitType<T['nullable']>>;
    or(arg: BinaryArg): Expression<BitType<T['nullable']>>;
    xor(arg: BinaryArg): Expression<BitType<T['nullable']>>;
    not(): Expression<BitType<T['nullable']>>;
    lshift(arg: IntegerArg): Expression<BitType<T['nullable']>>;
    rshift(arg: IntegerArg): Expression<BitType<T['nullable']>>;
}