import 'reflect-metadata';
import type { Combine, Type, TypeThunkAsync } from 'ts-gems';
import { OpraSchema } from '../../schema/index.js';
import type { ApiDocument } from '../api-document.js';
import type { DocumentElement } from '../common/document-element.js';
import { DocumentInitContext } from '../common/document-init-context.js';
import { ApiField } from './api-field.js';
import { ComplexTypeBase } from './complex-type-base.js';
import { DataType } from './data-type.js';
import type { MappedType } from './mapped-type.js';
import type { MixinType } from './mixin-type.js';
/**
 * @namespace ComplexType
 */
export declare namespace ComplexType {
    interface Metadata extends Combine<{
        kind: OpraSchema.ComplexType.Kind;
        fields?: Record<string, ApiField.Metadata>;
        additionalFields?: boolean | string | TypeThunkAsync | ['error'] | ['error', string];
    }, DataType.Metadata, OpraSchema.ComplexType> {
    }
    interface Options extends Combine<Pick<Metadata, 'additionalFields' | 'keyField' | 'discriminatorField' | 'discriminatorValue'>, DataType.Options, Pick<OpraSchema.ComplexType, 'abstract'>> {
    }
    interface InitArguments extends Combine<{
        kind: OpraSchema.ComplexType.Kind;
        base?: ComplexType | MappedType | MixinType;
        fields?: Record<string, ApiField.InitArguments | ApiField>;
        additionalFields?: boolean | DataType | ['error'] | ['error', string];
    }, DataType.InitArguments, ComplexType.Metadata> {
    }
    interface ParsedFieldPath {
        fieldName: string;
        dataType: DataType;
        field?: ApiField;
        additionalField?: boolean;
        sign?: '+' | '-';
    }
}
/**
 * Type definition for MixinType
 * @class ComplexType
 */
export interface ComplexTypeStatic {
    /**
     * Class constructor of ComplexType
     *
     * @param owner
     * @param args
     * @param context
     * @constructor
     */
    new (owner: DocumentElement, args?: ComplexType.InitArguments, context?: DocumentInitContext): ComplexType;
    (options?: ComplexType.Options): ClassDecorator;
    prototype: ComplexType;
    extend<T extends Type>(typeClass: T, fields: Record<string, ApiField.Options>): T;
}
/**
 * Type definition of ComplexType prototype
 * @interface ComplexType
 */
export interface ComplexType extends ComplexTypeClass {
}
/**
 * ComplexType constructor
 */
export declare const ComplexType: ComplexTypeStatic;
/**
 *
 * @class ComplexType
 */
declare abstract class ComplexTypeClass extends ComplexTypeBase {
    readonly kind: OpraSchema.ComplexType.Kind;
    readonly base?: ComplexType | MappedType | MixinType;
    readonly ctor?: Type;
    discriminatorField?: string;
    discriminatorValue?: string;
    extendsFrom(baseType: DataType | string | Type | object): boolean;
    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.ComplexType;
    protected _locateBase(callback: (base: ComplexTypeBase) => boolean): ComplexTypeBase | undefined;
}
export {};