import { Logger } from './logger.js';
import { IntrospectedNamespace } from './gir/namespace.js';
import { IntrospectedProperty, IntrospectedField } from './gir/property.js';
export { sanitizeMemberName, isInvalid } from './gir/util.js';
export { IntrospectedBase, Options as IntrospectedOptions, Metadata as IntrospectedMetadata, IntrospectedNamespaceMember, IntrospectedClassMember, } from './gir/base.js';
export { filterConflicts, filterFunctionConflict, FilterBehavior } from './gir/class.js';
export { promisifyFunctions } from './gir/promisify.js';
export { resolveDirectedType, resolvePrimitiveType } from './gir/util.js';
export * from './gir/nodes.js';
import type { OptionsBase } from './types/index.js';
export declare abstract class TypeExpression {
    isPointer: boolean;
    abstract equals(type: TypeExpression): boolean;
    abstract unwrap(): TypeExpression;
    deepUnwrap(): TypeExpression;
    abstract rewrap(type: TypeExpression): TypeExpression;
    abstract resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    abstract print(namespace: IntrospectedNamespace, options: OptionsBase): string;
    rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string;
}
export declare class TypeIdentifier extends TypeExpression {
    readonly name: string;
    readonly namespace: string;
    readonly log: Logger;
    constructor(name: string, namespace: string);
    equals(type: TypeExpression): boolean;
    is(namespace: string, name: string): boolean;
    unwrap(): this;
    rewrap(type: TypeExpression): TypeExpression;
    /**
     * TODO: gi.ts didn't deal with sanitizing types but probably should have to avoid
     * invalid names such as "3gppProfile"
     */
    sanitize(): TypeIdentifier;
    protected _resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null;
    resolveIdentifier(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    static new({ name, namespace }: {
        name: string;
        namespace: string;
    }): TypeIdentifier;
    print(namespace: IntrospectedNamespace, _options: OptionsBase): string;
}
export declare class ModuleTypeIdentifier extends TypeIdentifier {
    readonly moduleName: string;
    readonly namespace: string;
    constructor(name: string, moduleName: string, namespace: string);
    equals(type: TypeExpression): boolean;
    is(namespace: string, moduleName: string, name?: string): boolean;
    unwrap(): this;
    rewrap(type: TypeExpression): TypeExpression;
    sanitize(): ModuleTypeIdentifier;
    protected _resolve(namespace: IntrospectedNamespace, options: OptionsBase): ModuleTypeIdentifier | null;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
}
/**
 * This class overrides the default printing for types
 */
export declare class ClassStructTypeIdentifier extends TypeIdentifier {
    constructor(name: string, namespace: string);
    equals(type: TypeExpression): boolean;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
}
export declare class GenerifiedTypeIdentifier extends TypeIdentifier {
    generics: TypeExpression[];
    constructor(name: string, namespace: string, generics?: TypeExpression[]);
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
    _resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null;
}
export declare class NativeType extends TypeExpression {
    readonly expression: (options?: OptionsBase) => string;
    constructor(expression: ((options?: OptionsBase) => string) | string);
    rewrap(type: TypeExpression): TypeExpression;
    resolve(): TypeExpression;
    print(_namespace: IntrospectedNamespace, options: OptionsBase): string;
    equals(type: TypeExpression, options?: OptionsBase): boolean;
    unwrap(): TypeExpression;
    static withGenerator(generator: (options?: OptionsBase) => string): TypeExpression;
    static of(nativeType: string): NativeType;
}
export declare class OrType extends TypeExpression {
    readonly types: ReadonlyArray<TypeExpression>;
    constructor(type: TypeExpression, ...types: TypeExpression[]);
    rewrap(type: TypeExpression): TypeExpression;
    unwrap(): TypeExpression;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
    rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string;
    equals(type: TypeExpression): boolean;
}
export declare class TupleType extends OrType {
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
    rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    equals(type: TypeExpression): boolean;
}
export declare class BinaryType extends OrType {
    constructor(primary: TypeExpression, secondary: TypeExpression);
    unwrap(): TypeExpression;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): BinaryType;
    is(): boolean;
    get a(): TypeExpression;
    get b(): TypeExpression;
}
export declare class FunctionType extends TypeExpression {
    parameterTypes: {
        [name: string]: TypeExpression;
    };
    returnType: TypeExpression;
    constructor(parameters: {
        [name: string]: TypeExpression;
    }, returnType: TypeExpression);
    equals(type: TypeExpression): boolean;
    rewrap(type: TypeExpression): TypeExpression;
    unwrap(): TypeExpression;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
}
export declare class Generic {
    private _deriveFrom;
    private _genericType;
    private _defaultType;
    private _constraint;
    private _propagate;
    constructor(genericType: GenericType, defaultType?: TypeExpression, deriveFrom?: TypeIdentifier, constraint?: TypeExpression, propagate?: boolean);
    unwrap(): GenericType;
    get propagate(): boolean;
    get type(): GenericType;
    get defaultType(): TypeExpression | null;
    get constraint(): TypeExpression | null;
    get parent(): TypeIdentifier | null;
}
export declare class GenerifiedType extends TypeExpression {
    type: TypeExpression;
    generic: GenericType;
    constructor(type: TypeExpression, generic: GenericType);
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): GenerifiedType;
    unwrap(): TypeExpression;
    rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
    equals(type: TypeExpression): boolean;
    rewrap(type: TypeExpression): TypeExpression;
}
export declare class GenericType extends TypeExpression {
    identifier: string;
    replacedType?: TypeExpression;
    constructor(identifier: string, replacedType?: TypeExpression);
    equals(type: TypeExpression): boolean;
    unwrap(): TypeExpression;
    rewrap(type: TypeExpression): TypeExpression;
    resolve(): GenericType;
    print(): string;
}
export declare class NullableType extends BinaryType {
    constructor(type: TypeExpression);
    unwrap(): TypeExpression;
    rewrap(type: TypeExpression): TypeExpression;
    get type(): TypeExpression;
}
export declare class PromiseType extends TypeExpression {
    type: TypeExpression;
    constructor(type: TypeExpression);
    equals(type: TypeExpression): boolean;
    unwrap(): TypeExpression;
    rewrap(type: TypeExpression): TypeExpression;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
}
/**
 * A list of possible type conflicts.
 *
 * The format is CHILD_PARENT_CONFLICT so
 * ACCESSOR_PROPERTY_CONFLICT means there
 * is an accessor on a child class and a
 * property on the parent class, which is a
 * conflict.
 *
 * Starts at '1' because the value is often
 * used as truthy.
 */
export declare enum ConflictType {
    PROPERTY_NAME_CONFLICT = 1,
    FIELD_NAME_CONFLICT = 2,
    FUNCTION_NAME_CONFLICT = 3,
    ACCESSOR_PROPERTY_CONFLICT = 4,
    PROPERTY_ACCESSOR_CONFLICT = 5
}
/**
 * This is one of the more interesting usages of our type
 * system. To handle type conflicts we wrap conflicting types
 * in this class with a ConflictType to denote why they are a
 * conflict.
 *
 * TypeConflict will throw if it is printed or resolved, so generators
 * must unwrap it and "resolve" the conflict. Some generators like JSON
 * just disregard this info, other generators like DTS attempt to
 * resolve the conflicts so the typing stays sound.
 */
export declare class TypeConflict extends TypeExpression {
    readonly conflictType: ConflictType;
    readonly type: TypeExpression;
    constructor(type: TypeExpression, conflictType: ConflictType);
    rewrap(type: TypeExpression): TypeConflict;
    unwrap(): TypeExpression;
    equals(): boolean;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
}
export declare class ClosureType extends TypeExpression {
    type: TypeExpression;
    user_data: number | null;
    constructor(type: TypeExpression);
    equals(type: TypeExpression): boolean;
    deepUnwrap(): TypeExpression;
    rewrap(type: TypeExpression): TypeExpression;
    unwrap(): TypeExpression;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): ClosureType;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
    static new({ type, user_data }: {
        type: TypeExpression;
        user_data?: number | null;
    }): ClosureType;
}
export declare class ArrayType extends TypeExpression {
    type: TypeExpression;
    arrayDepth: number;
    length: number | null;
    constructor(type: TypeExpression);
    deepUnwrap(): TypeExpression;
    unwrap(): TypeExpression;
    rewrap(type: TypeExpression): TypeExpression;
    equals(type: TypeExpression): boolean;
    resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
    print(namespace: IntrospectedNamespace, options: OptionsBase): string;
    static new({ type, arrayDepth, length, }: {
        type: TypeExpression;
        length?: number | null;
        arrayDepth?: number;
    }): ArrayType;
}
export declare const ThisType: NativeType;
export declare const ObjectType: NativeType;
export declare const AnyType: NativeType;
export declare const NeverType: NativeType;
export declare const Uint8ArrayType: NativeType;
export declare const BooleanType: NativeType;
export declare const StringType: NativeType;
export declare const NumberType: NativeType;
export declare const NullType: NativeType;
export declare const VoidType: NativeType;
export declare const UnknownType: NativeType;
export declare const AnyFunctionType: NativeType;
export type GirClassField = IntrospectedProperty | IntrospectedField;