import { AllOfVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { AnyOfVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { ArrayElement } from '@swagger-api/apidom-core';
import { Attributes } from '@swagger-api/apidom-core';
import { BooleanElement } from '@swagger-api/apidom-core';
import { Class } from 'ts-mixer/dist/types/types.js';
import { DefinitionsVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { DefinitionsVisitor as DefinitionsVisitor_2 } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { DependenciesVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { DependenciesVisitor as DependenciesVisitor_2 } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { Element as Element_2 } from '@swagger-api/apidom-core';
import type { ElementPredicate } from '@swagger-api/apidom-core';
import { EnumVisitor } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { isArrayElement } from '@swagger-api/apidom-core';
import { isBooleanElement } from '@swagger-api/apidom-core';
import { isElement } from '@swagger-api/apidom-core';
import { isLinkElement } from '@swagger-api/apidom-core';
import { isMemberElement } from '@swagger-api/apidom-core';
import { isNullElement } from '@swagger-api/apidom-core';
import { isNumberElement } from '@swagger-api/apidom-core';
import { isObjectElement } from '@swagger-api/apidom-core';
import { isRefElement } from '@swagger-api/apidom-core';
import { isStringElement } from '@swagger-api/apidom-core';
import { ItemsVisitor } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { JSONSchemaDraft4ItemsVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { JSONSchemaElement } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { LinkDescriptionVisitor } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { MediaTypes } from '@swagger-api/apidom-core';
import { MemberElement } from '@swagger-api/apidom-core';
import { Meta } from '@swagger-api/apidom-core';
import { Namespace } from 'minim';
import { NamespacePluginOptions } from '@swagger-api/apidom-core';
import { NumberElement } from '@swagger-api/apidom-core';
import { ObjectElement } from '@swagger-api/apidom-core';
import { ObjectElement as ObjectElement_2 } from 'minim';
import { OneOfVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { PatternPropertiesVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { PatternPropertiesVisitor as PatternPropertiesVisitor_2 } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { PropertiesVisitor } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { PropertiesVisitor as PropertiesVisitor_2 } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { AllOfVisitorOptions as SchemaAllOfVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { AnyOfVisitorOptions as SchemaAnyOfVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { DefinitionsVisitorOptions as SchemaDefinitionsVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { DependenciesVisitorOptions as SchemaDependenciesVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { ItemsVisitorOptions as SchemaItemsVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { OneOfVisitorOptions as SchemaOneOfVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { SchemaOrReferenceVisitor as SchemaOrReferenceVisitor_2 } from '@swagger-api/apidom-ns-json-schema-draft-4';
import { SchemaOrReferenceVisitor as SchemaOrReferenceVisitor_3 } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { SchemaOrReferenceVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { PatternPropertiesVisitorOptions as SchemaPatternPropertiesVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { PropertiesVisitorOptions as SchemaPropertiesVisitorOptions } from '@swagger-api/apidom-ns-json-schema-draft-7';
import { StringElement } from '@swagger-api/apidom-core';
import { TypeVisitor } from '@swagger-api/apidom-ns-json-schema-draft-4';

/**
 * @public
 */
export declare class AlternatingVisitor extends SpecificationVisitor {
    protected alternator: Alternator[];
    constructor({ alternator, ...rest }: AlternatingVisitorOptions);
    enter(element: Element_2): {};
}

/**
 * @public
 */
export declare interface AlternatingVisitorOptions extends SpecificationVisitorOptions {
    readonly alternator: Alternator[];
}

/**
 * @public
 */
export declare type Alternator = {
    predicate: (element: unknown) => boolean;
    specPath: string[];
};

/**
 * @public
 */
export declare class Amqp1ChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Amqp1ChannelBindingVisitor extends Amqp1ChannelBindingVisitor_base {
    readonly element: Amqp1ChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp1',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Amqp1ChannelBindingVisitorOptions);
}

declare const Amqp1ChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Amqp1ChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class Amqp1MessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Amqp1MessageBindingVisitor extends Amqp1MessageBindingVisitor_base {
    readonly element: Amqp1MessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp1',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Amqp1MessageBindingVisitorOptions);
}

declare const Amqp1MessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Amqp1MessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class Amqp1OperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Amqp1OperationBindingVisitor extends Amqp1OperationBindingVisitor_base {
    readonly element: Amqp1OperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp1',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Amqp1OperationBindingVisitorOptions);
}

declare const Amqp1OperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Amqp1OperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class Amqp1ServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Amqp1ServerBindingVisitor extends Amqp1ServerBindingVisitor_base {
    readonly element: Amqp1ServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp1',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Amqp1ServerBindingVisitorOptions);
}

declare const Amqp1ServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Amqp1ServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AmqpChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get is(): StringElement | undefined;
    set is(is: StringElement | undefined);
    get exchange(): ObjectElement | undefined;
    set exchange(exchange: ObjectElement | undefined);
    get queue(): ObjectElement | undefined;
    set queue(queue: ObjectElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class AmqpChannelBindingVisitor extends AmqpChannelBindingVisitor_base {
    readonly element: AmqpChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AmqpChannelBindingVisitorOptions);
}

declare const AmqpChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AmqpChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AmqpMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get contentEncoding(): StringElement | undefined;
    set contentEncoding(contentEncoding: StringElement | undefined);
    get messageType(): StringElement | undefined;
    set messageType(messageType: StringElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class AmqpMessageBindingVisitor extends AmqpMessageBindingVisitor_base {
    readonly element: AmqpMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AmqpMessageBindingVisitorOptions);
}

declare const AmqpMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AmqpMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AmqpOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get expiration(): NumberElement | undefined;
    set expiration(expiration: NumberElement | undefined);
    get userId(): StringElement | undefined;
    set userId(userId: StringElement | undefined);
    get cc(): ArrayElement | undefined;
    set cc(cc: ArrayElement | undefined);
    get priority(): NumberElement | undefined;
    set priority(priority: NumberElement | undefined);
    get deliveryMode(): NumberElement | undefined;
    set deliveryMode(deliveryMode: NumberElement | undefined);
    get mandatory(): BooleanElement | undefined;
    set mandatory(mandatory: BooleanElement | undefined);
    get bcc(): ArrayElement | undefined;
    set bcc(bcc: ArrayElement | undefined);
    get replyTo(): StringElement | undefined;
    set replyTo(replyTo: StringElement | undefined);
    get timestamp(): BooleanElement | undefined;
    set timestamp(timestamp: BooleanElement | undefined);
    get ack(): BooleanElement | undefined;
    set ack(ack: BooleanElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class AmqpOperationBindingVisitor extends AmqpOperationBindingVisitor_base {
    readonly element: AmqpOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AmqpOperationBindingVisitorOptions);
}

declare const AmqpOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AmqpOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AmqpServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class AmqpServerBindingVisitor extends AmqpServerBindingVisitor_base {
    readonly element: AmqpServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AmqpServerBindingVisitorOptions);
}

declare const AmqpServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AmqpServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AnypointmqChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get destination(): StringElement | undefined;
    set destination(destination: StringElement | undefined);
    get destinationType(): StringElement | undefined;
    set destinationType(destinationType: StringElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class AnypointmqChannelBindingVisitor extends AnypointmqChannelBindingVisitor_base {
    readonly element: AnypointmqChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'anypointmq',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AnypointmqChannelBindingVisitorOptions);
}

declare const AnypointmqChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AnypointmqChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AnypointmqMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get headers(): SchemaElement | ReferenceElement | undefined;
    set headers(headers: SchemaElement | ReferenceElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class AnypointmqMessageBindingVisitor extends AnypointmqMessageBindingVisitor_base {
    readonly element: AnypointmqMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'anypointmq',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AnypointmqMessageBindingVisitorOptions);
}

declare const AnypointmqMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AnypointmqMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AnypointmqOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class AnypointmqOperationBindingVisitor extends AnypointmqOperationBindingVisitor_base {
    readonly element: AnypointmqOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'anypointmq',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AnypointmqOperationBindingVisitorOptions);
}

declare const AnypointmqOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AnypointmqOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AnypointmqServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class AnypointmqServerBindingVisitor extends AnypointmqServerBindingVisitor_base {
    readonly element: AnypointmqServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'anypointmq',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AnypointmqServerBindingVisitorOptions);
}

declare const AnypointmqServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AnypointmqServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
declare const asyncApi2: {
    namespace: (options: NamespacePluginOptions) => Namespace;
};
export default asyncApi2;

/**
 * @public
 */
export declare class AsyncApi2Element extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get asyncapi(): AsyncApiVersionElement | undefined;
    set asyncapi(asyncapi: AsyncApiVersionElement | undefined);
    get idProp(): IdentifierElement | undefined;
    set idProp(id: IdentifierElement | undefined);
    get info(): InfoElement | undefined;
    set info(info: InfoElement | undefined);
    get servers(): ServersElement | undefined;
    set servers(servers: ServersElement | undefined);
    get defaultContentType(): DefaultContentTypeElement | undefined;
    set defaultContentType(defaultContentType: DefaultContentTypeElement | undefined);
    get channels(): ChannelsElement | undefined;
    set channels(channels: ChannelsElement | undefined);
    get components(): ComponentsElement | undefined;
    set components(components: ComponentsElement | undefined);
    get tags(): TagsElement | undefined;
    set tags(tags: TagsElement | undefined);
    get externalDocs(): ExternalDocumentationElement | undefined;
    set externalDocs(externalDocs: ExternalDocumentationElement | undefined);
}

/**
 * @public
 */
export declare class AsyncApi2Visitor extends AsyncApi2Visitor_base {
    readonly element: AsyncApi2Element;
    protected readonly specPath: SpecPath<['document', 'objects', 'AsyncApi']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: AsyncApi2VisitorOptions);
}

declare const AsyncApi2Visitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AsyncApi2VisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class AsyncAPIMediaTypes extends MediaTypes<string> {
    filterByFormat(format?: Format): string[];
    findBy(version?: string, format?: Format): string;
    latest(format?: Format): string;
}

/**
 * @public
 */
export declare class AsyncApiVersionElement extends StringElement {
    constructor(content?: string, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class AsyncApiVersionVisitor extends AsyncApiVersionVisitor_base {
    element: AsyncApiVersionElement;
    StringElement(stringElement: StringElement): {};
}

declare const AsyncApiVersionVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface AsyncApiVersionVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

declare const BindingsVisitor_base: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

declare const BindingsVisitor_base_2: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

declare const BindingsVisitor_base_3: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

declare const BindingsVisitor_base_4: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

declare const BindingsVisitor_base_5: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

declare const BindingsVisitor_base_6: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class ChannelBindingsElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get http(): HttpChannelBindingElement | undefined;
    set http(http: HttpChannelBindingElement | undefined);
    get ws(): WebSocketChannelBindingElement | undefined;
    set ws(ws: WebSocketChannelBindingElement | undefined);
    get kafka(): KafkaChannelBindingElement | undefined;
    set kafka(kafka: KafkaChannelBindingElement | undefined);
    get anypointmq(): AnypointmqChannelBindingElement | undefined;
    set anypointmq(anypointmq: AnypointmqChannelBindingElement | undefined);
    get amqp(): AmqpChannelBindingElement | undefined;
    set amqp(amqp: AmqpChannelBindingElement | undefined);
    get amqp1(): Amqp1ChannelBindingElement | undefined;
    set amqp1(amqp1: Amqp1ChannelBindingElement | undefined);
    get mqtt(): MqttChannelBindingElement | undefined;
    set mqtt(mqtt: MqttChannelBindingElement | undefined);
    get mqtt5(): Mqtt5ChannelBindingElement | undefined;
    set mqtt5(mqtt5: Mqtt5ChannelBindingElement | undefined);
    get nats(): NatsChannelBindingElement | undefined;
    set nats(nats: NatsChannelBindingElement | undefined);
    get jms(): JmsChannelBindingElement | undefined;
    set jms(jms: JmsChannelBindingElement | undefined);
    get sns(): SnsChannelBindingElement | undefined;
    set sns(sns: SnsChannelBindingElement | undefined);
    get solace(): SolaceChannelBindingElement | undefined;
    set solace(solace: SolaceChannelBindingElement | undefined);
    get sqs(): SqsChannelBindingElement | undefined;
    set sqs(sqs: SqsChannelBindingElement | undefined);
    get stomp(): StompChannelBindingElement | undefined;
    set stomp(stomp: StompChannelBindingElement | undefined);
    get redis(): RedisChannelBindingElement | undefined;
    set redis(redis: RedisChannelBindingElement | undefined);
    get mercure(): MercureChannelBindingElement | undefined;
    set mercure(mercure: MercureChannelBindingElement | undefined);
    get googlepubsub(): GooglepubsubChannelBindingElement | undefined;
    set googlepubsub(googlepubsub: GooglepubsubChannelBindingElement | undefined);
    get ibmmq(): IbmmqChannelBindingElement | undefined;
    set ibmmq(ibmmq: IbmmqChannelBindingElement | undefined);
}

/**
 * @public
 */
export declare class ChannelBindingsVisitor extends ChannelBindingsVisitor_base_2 {
    readonly element: ChannelBindingsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ChannelBindings']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ChannelBindingsVisitorOptions);
}

declare const ChannelBindingsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

declare const ChannelBindingsVisitor_base_2: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ChannelBindingsVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ChannelItem$RefVisitor extends FallbackVisitor {
    readonly element: StringElement;
    StringElement(stringElement: StringElement): {};
}

/**
 * @public
 */
export declare class ChannelItemBindingsVisitor extends BindingsVisitor_base_2 {
    constructor(options: ChannelItemBindingsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ChannelItemBindingsVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ChannelItemElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get $ref(): StringElement | undefined;
    set $ref($ref: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get servers(): ArrayElement | undefined;
    set servers(servers: ArrayElement | undefined);
    get subscribe(): OperationElement | undefined;
    set subscribe(subscribe: OperationElement | undefined);
    get publish(): OperationElement | undefined;
    set publish(publish: OperationElement | undefined);
    get parameters(): ParametersElement | undefined;
    set parameters(parameters: ParametersElement | undefined);
    get bindings(): ChannelBindingsElement | undefined;
    set bindings(bindings: ChannelBindingsElement | undefined);
}

/**
 * @public
 */
export declare class ChannelItemServersVisitor extends ServersVisitor_base_2 {
    readonly element: ChannelItemsServersElement;
    constructor(options: ChannelItemServersVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

/**
 * @public
 */
export declare interface ChannelItemServersVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ChannelItemsServersElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ChannelItemVisitor extends ChannelItemVisitor_base {
    readonly element: ChannelItemElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ChannelItem']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ChannelItemVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

declare const ChannelItemVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ChannelItemVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ChannelsElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ChannelsVisitor extends ChannelsVisitor_base {
    readonly element: ChannelsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ChannelItem']>;
    constructor(options: ChannelsVisitorOptions);
}

declare const ChannelsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

declare const ChannelsVisitor_base_2: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ChannelsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsChannelBindingsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsChannelBindingsVisitor extends ChannelBindingsVisitor_base {
    readonly element: ComponentsChannelBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ChannelBindings']>;
    constructor(options: ComponentsChannelBindingsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsChannelBindingsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsChannelsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsChannelsVisitor extends ChannelsVisitor_base_2 {
    readonly element: ComponentsChannelsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ChannelItem']>;
    constructor(options: ComponentsChannelsVisitorOptions);
}

/**
 * @public
 */
export declare interface ComponentsChannelsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsCorrelationIDsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsCorrelationIdsVisitor extends CorrelationIdsVisitor_base {
    readonly element: ComponentsCorrelationIDsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'CorrelationID']>;
    constructor(options: ComponentsCorrelationIdsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsCorrelationIdsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get schemas(): ObjectElement | undefined;
    set schemas(schemas: ObjectElement | undefined);
    get servers(): ObjectElement | undefined;
    set servers(servers: ObjectElement | undefined);
    get serverVariables(): ObjectElement | undefined;
    set serverVariables(serverVariables: ObjectElement | undefined);
    get messages(): ObjectElement | undefined;
    set messages(messages: ObjectElement | undefined);
    get securitySchemes(): ObjectElement | undefined;
    set securitySchemes(securitySchemes: ObjectElement | undefined);
    get parameters(): ObjectElement | undefined;
    set parameters(parameters: ObjectElement | undefined);
    get correlationIds(): ObjectElement | undefined;
    set correlationIds(correlationIds: ObjectElement | undefined);
    get operationTraits(): ObjectElement | undefined;
    set operationTraits(operationTraits: ObjectElement | undefined);
    get messageTraits(): ObjectElement | undefined;
    set messageTraits(messageTraits: ObjectElement | undefined);
    get serverBindings(): ObjectElement | undefined;
    set serverBindings(serverBindings: ObjectElement | undefined);
    get channelBindings(): ObjectElement | undefined;
    set channelBindings(channelBindings: ObjectElement | undefined);
    get operationBindings(): ObjectElement | undefined;
    set operationBindings(operationBindings: ObjectElement | undefined);
    get messageBindings(): ObjectElement | undefined;
    set messageBindings(messageBindings: ObjectElement | undefined);
}

/**
 * @public
 */
export declare class ComponentsMessageBindingsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsMessageBindingsVisitor extends MessageBindingsVisitor_base {
    element: ComponentsMessageBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'MessageBindings']>;
    constructor(options: ComponentsMessageBindingsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsMessageBindingsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsMessagesElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsMessagesVisitor extends MessagesVisitor_base {
    readonly element: ComponentsMessagesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Message']>;
    constructor(options: ComponentsMessagesVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsMessagesVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsMessageTraitsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsMessageTraitsVisitor extends MessageTraitsVisitor_base {
    readonly element: ComponentsMessageTraitsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'MessageTrait']>;
    constructor(options: ComponentsMessageTraitsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsMessageTraitsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsOperationBindingsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsOperationBindingsVisitor extends OperationBindingsVisitor_base {
    readonly element: ComponentsOperationBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'OperationBindings']>;
    constructor(options: ComponentsOperationBindingsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsOperationBindingsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsOperationTraitsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsOperationTraitsVisitor extends OperationTraitsVisitor_base {
    readonly element: ComponentsOperationTraitsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'OperationTrait']>;
    constructor(options: ComponentsOperationTraitsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsOperationTraitsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsParametersElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsParametersVisitor extends ParametersVisitor_base {
    readonly element: ComponentsParametersElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Parameter']>;
    constructor(options: ComponentsParametersVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsParametersVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsSchemasElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsSchemasVisitor extends SchemasVisitor_base {
    readonly element: ComponentsSchemasElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Schema']>;
    constructor(options: ComponentsSchemasVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsSchemasVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsSecuritySchemesElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsSecuritySchemesVisitor extends SecuritySchemesVisitor_base {
    element: ComponentsSecuritySchemesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'SecurityScheme']>;
    constructor(options: ComponentsSecuritySchemesVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsSecuritySchemesVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsServerBindingsElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsServerBindingsVisitor extends ServerBindingsVisitor_base {
    element: ComponentsServerBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ServerBindings']>;
    constructor(options: ComponentsServerBindingsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsServerBindingsVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsServersElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsServersVisitor extends ServersVisitor_base_3 {
    readonly element: ComponentsServersElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Server']>;
    constructor(options: ComponentsServersVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsServersVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsServerVariablesElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ComponentsServerVariablesVisitor extends ServerVariablesVisitor_base {
    readonly element: ComponentsServerVariablesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ServerVariable']>;
    constructor(options: ComponentsServerVariablesVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ComponentsServerVariablesVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ComponentsVisitor extends ComponentsVisitor_base {
    readonly element: ComponentsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Components']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ComponentsVisitorOptions);
}

declare const ComponentsVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ComponentsVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ContactElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get name(): StringElement | undefined;
    set name(name: StringElement | undefined);
    get url(): StringElement | undefined;
    set url(url: StringElement | undefined);
    get email(): StringElement | undefined;
    set email(email: StringElement | undefined);
}

/**
 * @public
 */
export declare class ContactVisitor extends ContactVisitor_base {
    readonly element: ContactElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Contact']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ContactVisitorOptions);
}

declare const ContactVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ContactVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class CorrelationIDElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get location(): StringElement | undefined;
    set location(location: StringElement | undefined);
}

declare const CorrelationIdsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class CorrelationIDVisitor extends CorrelationIDVisitor_base {
    readonly element: CorrelationIDElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'CorrelationID']>;
    constructor(options: CorrelationIDVisitorOptions);
}

declare const CorrelationIDVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

declare const CorrelationIdVisitor_base: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

declare const CorrelationIdVisitor_base_2: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface CorrelationIDVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class DefaultContentTypeElement extends StringElement {
    constructor(content?: string, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class DefaultContentTypeVisitor extends DefaultContentTypeVisitor_base {
    element: DefaultContentTypeElement;
    StringElement(stringElement: StringElement): {};
}

declare const DefaultContentTypeVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface DefaultContentTypeVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

declare const DefaultVisitor_base: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

declare const ExamplesVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

declare const ExamplesVisitor_base_2: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class ExternalDocumentationElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get url(): StringElement | undefined;
    set url(url: StringElement | undefined);
}

/**
 * @public
 */
export declare class ExternalDocumentationVisitor extends ExternalDocumentationVisitor_base {
    readonly element: ExternalDocumentationElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ExternalDocumentation']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ExternalDocumentationVisitorOptions);
}

declare const ExternalDocumentationVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ExternalDocumentationVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class FallbackVisitor extends Visitor {
    enter(element: Element_2): {};
}

/**
 * @public
 */
export declare class FixedFieldsVisitor extends SpecificationVisitor {
    protected specPath: SpecPath;
    protected ignoredFields: string[];
    protected canSupportSpecificationExtensions: boolean;
    protected specificationExtensionPredicate: (element: MemberElement) => boolean;
    constructor({ specPath, ignoredFields, canSupportSpecificationExtensions, specificationExtensionPredicate, ...rest }: FixedFieldsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface FixedFieldsVisitorOptions extends SpecificationVisitorOptions {
    readonly specPath: SpecPath;
    readonly ignoredFields?: string[];
    readonly canSupportSpecificationExtensions?: boolean;
    readonly specificationExtensionPredicate?: typeof isAsyncApiExtension;
}

/**
 * @public
 */
export declare type Format = 'generic' | 'json' | 'yaml';

/**
 * @public
 */
export declare const getNodeType: <T extends Element_2>(element: T) => string | undefined;

/**
 * @public
 */
export declare class GooglepubsubChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
    get labels(): ObjectElement | undefined;
    set labels(labels: ObjectElement | undefined);
    get messageRetentionDuration(): StringElement | undefined;
    set messageRetentionDuration(messageRetentionDuration: StringElement | undefined);
    get messageStoragePolicy(): ObjectElement | undefined;
    set messageStoragePolicy(messageStoragePolicy: ObjectElement | undefined);
    get schemaSettings(): ObjectElement | undefined;
    set schemaSettings(schemaSettings: ObjectElement | undefined);
    get topic(): StringElement | undefined;
    set topic(topic: StringElement | undefined);
}

/**
 * @public
 */
export declare class GooglepubsubChannelBindingVisitor extends GooglepubsubChannelBindingVisitor_base {
    readonly element: GooglepubsubChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'googlepubsub',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: GooglepubsubChannelBindingVisitorOptions);
}

declare const GooglepubsubChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface GooglepubsubChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class GooglepubsubMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
    get attributesProp(): ObjectElement | undefined;
    set attributesProp(attributes: ObjectElement | undefined);
    get orderingKey(): StringElement | undefined;
    set orderingKey(orderingKey: StringElement | undefined);
    get schema(): ObjectElement | undefined;
    set schema(schema: ObjectElement | undefined);
}

/**
 * @public
 */
export declare class GooglepubsubMessageBindingVisitor extends GooglepubsubMessageBindingVisitor_base {
    readonly element: GooglepubsubMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'googlepubusb',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: GooglepubsubMessageBindingVisitorOptions);
}

declare const GooglepubsubMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface GooglepubsubMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class GooglepubsubOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class GooglepubsubOperationBindingVisitor extends GooglepubsubOperationBindingVisitor_base {
    readonly element: GooglepubsubOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'googlepubsub',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: GooglepubsubOperationBindingVisitorOptions);
}

declare const GooglepubsubOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface GooglepubsubOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class GooglepubsubServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class GooglepubsubServerBindingVisitor extends GooglepubsubServerBindingVisitor_base {
    readonly element: GooglepubsubServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'googlepubsub',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: GooglepubsubServerBindingVisitorOptions);
}

declare const GooglepubsubServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface GooglepubsubServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

declare const HeadersVisitor_base: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class HttpChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class HttpChannelBindingVisitor extends HttpChannelBindingVisitor_base {
    readonly element: HttpChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'http',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: HttpChannelBindingVisitorOptions);
}

declare const HttpChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface HttpChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class HttpMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get headers(): SchemaElement | ReferenceElement | undefined;
    set headers(headers: SchemaElement | ReferenceElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class HttpMessageBindingVisitor extends HttpMessageBindingVisitor_base {
    readonly element: HttpMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'http',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: HttpMessageBindingVisitorOptions);
}

declare const HttpMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface HttpMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class HttpOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get type(): StringElement | undefined;
    set type(type: StringElement | undefined);
    get method(): StringElement | undefined;
    set method(method: StringElement | undefined);
    get query(): SchemaElement | ReferenceElement | undefined;
    set query(query: SchemaElement | ReferenceElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class HttpOperationBindingVisitor extends HttpOperationBindingVisitor_base {
    readonly element: HttpOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'http',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: HttpOperationBindingVisitorOptions);
}

declare const HttpOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface HttpOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class HttpServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class HttpServerBindingVisitor extends HttpServerBindingVisitor_base {
    readonly element: HttpServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'http',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: HttpServerBindingVisitorOptions);
}

declare const HttpServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface HttpServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class IbmmqChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get destinationType(): StringElement | undefined;
    set destinationType(destinationType: StringElement | undefined);
    get queue(): ObjectElement | undefined;
    set queue(queue: ObjectElement | undefined);
    get topic(): ObjectElement | undefined;
    set topic(topic: ObjectElement | undefined);
    get maxMsgLength(): NumberElement | undefined;
    set maxMsgLength(maxMsgLength: NumberElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class IbmmqChannelBindingVisitor extends IbmmqChannelBindingVisitor_base {
    readonly element: IbmmqChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ibmmq',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: IbmmqChannelBindingVisitorOptions);
}

declare const IbmmqChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface IbmmqChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class IbmmqMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get type(): StringElement | undefined;
    set type(type: StringElement | undefined);
    get headers(): StringElement | undefined;
    set headers(headers: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get expiry(): NumberElement | undefined;
    set expiry(expiry: NumberElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class IbmmqMessageBindingVisitor extends IbmmqMessageBindingVisitor_base {
    readonly element: IbmmqMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ibmmq',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: IbmmqMessageBindingVisitorOptions);
}

declare const IbmmqMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface IbmmqMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class IbmmqOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class IbmmqOperationBindingVisitor extends IbmmqOperationBindingVisitor_base {
    readonly element: IbmmqOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ibmmq',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: IbmmqOperationBindingVisitorOptions);
}

declare const IbmmqOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface IbmmqOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class IbmmqServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get groupId(): StringElement | undefined;
    set groupId(groupId: StringElement | undefined);
    get ccdtQueueManagerName(): StringElement | undefined;
    set ccdtQueueManagerName(ccdtQueueManagerName: StringElement | undefined);
    get cipherSpec(): StringElement | undefined;
    set cipherSpec(cipherSpec: StringElement | undefined);
    get multiEndpointServer(): BooleanElement | undefined;
    set multiEndpointServer(multiEndpointServer: BooleanElement | undefined);
    get heartBeatInterval(): NumberElement | undefined;
    set heartBeatInterval(heartBeatInterval: NumberElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class IbmmqServerBindingVisitor extends IbmmqServerBindingVisitor_base {
    readonly element: IbmmqServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ibmmq',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: IbmmqServerBindingVisitorOptions);
}

declare const IbmmqServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface IbmmqServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class IdentifierElement extends StringElement {
    constructor(content?: string, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class IdentifierVisitor extends IdentifierVisitor_base {
    element: IdentifierElement;
    StringElement(stringElement: StringElement): {};
}

declare const IdentifierVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface IdentifierVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class InfoElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get title(): StringElement | undefined;
    set title(title: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get termsOfService(): StringElement | undefined;
    set termsOfService(tos: StringElement | undefined);
    get version(): StringElement | undefined;
    set version(version: StringElement | undefined);
    get license(): LicenseElement | undefined;
    set license(licenseElement: LicenseElement | undefined);
    get contact(): ContactElement | undefined;
    set contact(contactElement: ContactElement | undefined);
}

/**
 * @public
 */
export declare class InfoVersionVisitor extends FallbackVisitor {
    element: StringElement;
    StringElement(stringElement: StringElement): {};
}

/**
 * @public
 */
export declare class InfoVisitor extends InfoVisitor_base {
    readonly element: InfoElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Info']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: InfoVisitorOptions);
}

declare const InfoVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface InfoVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

export { isArrayElement }

/**
 * @public
 */
export declare const isAsyncApi2Element: ElementPredicate<AsyncApi2Element>;

/**
 * @public
 */
export declare const isAsyncApiExtension: (element: MemberElement) => boolean;

/**
 * @public
 */
export declare const isAsyncApiVersionElement: ElementPredicate<AsyncApiVersionElement>;

export { isBooleanElement }

/**
 * @public
 */
export declare const isBooleanJsonSchemaElement: ElementPredicate<BooleanElement>;

/**
 * @public
 */
export declare const isChannelBindingsElement: ElementPredicate<ChannelBindingsElement>;

/**
 * @public
 */
export declare const isChannelItemElement: ElementPredicate<ChannelItemElement>;

/**
 * @public
 */
export declare const isChannelsElement: ElementPredicate<ChannelsElement>;

/**
 * @public
 */
export declare const isComponentsElement: ElementPredicate<ComponentsElement>;

/**
 * @public
 */
export declare const isContactElement: ElementPredicate<ContactElement>;

export { isElement }

/**
 * @public
 */
export declare const isIdentifierElement: ElementPredicate<IdentifierElement>;

/**
 * @public
 */
export declare const isInfoElement: ElementPredicate<InfoElement>;

/**
 * @public
 */
export declare const isLicenseElement: ElementPredicate<LicenseElement>;

export { isLinkElement }

export { isMemberElement }

export { isNullElement }

export { isNumberElement }

export { isObjectElement }

/**
 * @public
 */
export declare const isOperationElement: ElementPredicate<OperationElement>;

/**
 * @public
 */
export declare const isParameterElement: ElementPredicate<ParameterElement>;

/**
 * @public
 */
export declare const isParametersElement: ElementPredicate<ParametersElement>;

export { isRefElement }

/**
 * @public
 */
export declare const isReferenceElement: ElementPredicate<ReferenceElement>;

/**
 * @public
 */
export declare const isReferenceLikeElement: (element: unknown) => element is ReferenceLikeElement;

/**
 * @public
 */
export declare const isSchemaElement: ElementPredicate<SchemaElement>;

/**
 * @public
 */
export declare const isSecurityRequirementElement: ElementPredicate<SecurityRequirementElement>;

/**
 * @public
 */
export declare const isServerBindingsElement: ElementPredicate<ServerBindingsElement>;

/**
 * @public
 */
export declare const isServerElement: ElementPredicate<ServerElement>;

/**
 * @public
 */
export declare const isServersElement: ElementPredicate<ServersElement>;

/**
 * @public
 */
export declare const isServerVariableElement: ElementPredicate<ServerVariableElement>;

export { isStringElement }

/**
 * @public
 */
export declare class JmsChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class JmsChannelBindingVisitor extends JmsChannelBindingVisitor_base {
    readonly element: JmsChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'jms',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: JmsChannelBindingVisitorOptions);
}

declare const JmsChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface JmsChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class JmsMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class JmsMessageBindingVisitor extends JmsMessageBindingVisitor_base {
    readonly element: JmsMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'jms',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: JmsMessageBindingVisitorOptions);
}

declare const JmsMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface JmsMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class JmsOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class JmsOperationBindingVisitor extends JmsOperationBindingVisitor_base {
    readonly element: JmsOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'jms',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: JmsOperationBindingVisitorOptions);
}

declare const JmsOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface JmsOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class JmsServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class JmsServerBindingVisitor extends JmsServerBindingVisitor_base {
    readonly element: JmsServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'jms',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: JmsServerBindingVisitorOptions);
}

declare const JmsServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface JmsServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare const JSONSchemaAllOfVisitor: typeof AllOfVisitor;

/**
 * @public
 */
export declare const JSONSchemaAnyOfVisitor: typeof AnyOfVisitor;

/**
 * @public
 */
export declare const JSONSchemaDefinitionsVisitor: typeof DefinitionsVisitor;

/**
 * @public
 */
export declare const JSONSchemaDependenciesVisitor: typeof DependenciesVisitor;

/**
 * @public
 */
export declare const JSONSchemaItemsVisitor: typeof JSONSchemaDraft4ItemsVisitor;

/**
 * @public
 */
export declare const JSONSchemaOneOfVisitor: typeof OneOfVisitor;

/**
 * @public
 */
export declare const JSONSchemaOrJSONReferenceVisitor: typeof SchemaOrReferenceVisitor_3;

/**
 * @public
 */
export declare const JSONSchemaPatternPropertiesVisitor: typeof PatternPropertiesVisitor;

/**
 * @public
 */
export declare const JSONSchemaPropertiesVisitor: typeof PropertiesVisitor;

/**
 * @public
 */
export declare class KafkaChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get topic(): StringElement | undefined;
    set topic(topic: StringElement | undefined);
    get partitions(): NumberElement | undefined;
    set partitions(partitions: NumberElement | undefined);
    get replicas(): NumberElement | undefined;
    set replicas(replicas: NumberElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class KafkaChannelBindingVisitor extends KafkaChannelBindingVisitor_base {
    readonly element: KafkaChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaChannelBindingVisitorOptions);
}

declare const KafkaChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface KafkaChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class KafkaMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get key(): SchemaElement | ReferenceElement | undefined;
    set key(key: SchemaElement | ReferenceElement | undefined);
    get schemaIdLocation(): StringElement | undefined;
    set schemaIdLocation(schemaIdLocation: StringElement | undefined);
    get schemaIdPayloadEncoding(): StringElement | undefined;
    set schemaIdPayloadEncoding(schemaIdPayloadEncoding: StringElement | undefined);
    get schemaLookupStrategy(): StringElement | undefined;
    set schemaLookupStrategy(schemaLookupStrategy: StringElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class KafkaMessageBindingVisitor extends KafkaMessageBindingVisitor_base {
    readonly element: KafkaMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaMessageBindingVisitorOptions);
}

declare const KafkaMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface KafkaMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class KafkaOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get groupId(): SchemaElement | ReferenceElement | undefined;
    set groupId(groupId: SchemaElement | ReferenceElement | undefined);
    get clientId(): SchemaElement | ReferenceElement | undefined;
    set clientId(clientId: SchemaElement | ReferenceElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class KafkaOperationBindingVisitor extends KafkaOperationBindingVisitor_base {
    readonly element: KafkaOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaOperationBindingVisitorOptions);
}

declare const KafkaOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface KafkaOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class KafkaServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get schemaRegistryUrl(): StringElement | undefined;
    set schemaRegistryUrl(schemaRegistryUrl: StringElement | undefined);
    get schemaRegistryVendor(): StringElement | undefined;
    set schemaRegistryVendor(schemaRegistryVendor: StringElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class KafkaServerBindingVisitor extends KafkaServerBindingVisitor_base {
    readonly element: KafkaServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaServerBindingVisitorOptions);
}

declare const KafkaServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface KafkaServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare const keyMap: {
    ObjectElement: string[];
    ArrayElement: string[];
    MemberElement: string[];
    StringElement: never[];
    BooleanElement: never[];
    NumberElement: never[];
    NullElement: never[];
    RefElement: never[];
    LinkElement: never[];
    Annotation: never[];
    Comment: never[];
    ParseResultElement: string[];
    SourceMap: string[];
    /**
     * `AsyncApi >= 2.0.0 <=2.6.0` specification elements.
     */
    AsyncApi2Element: string[];
    AsyncApiVersionElement: never[];
    ChannelBindingsElement: string[];
    ChannelItemElement: string[];
    ChannelsElement: string[];
    ComponentsElement: string[];
    ContactElement: string[];
    CorrelationIDElement: string[];
    DefaultContentType: never[];
    ExternalDocumentationElement: string[];
    InfoElement: string[];
    LicenseElement: string[];
    MessageElement: string[];
    MessageBindingsElement: string[];
    MessageTraitElement: string[];
    OAuthFlowElement: string[];
    OAuthFlowsElement: string[];
    OperationElement: string[];
    OperationBindingsElement: string[];
    OperationTraitElement: string[];
    ParameterElement: string[];
    ParametersElement: string[];
    ReferenceElement: string[];
    SchemaElement: string[];
    SecurityRequirementElement: string[];
    SecuritySchemeElement: string[];
    ServerElement: string[];
    ServerBindingsElement: string[];
    ServersElement: string[];
    ServerVariableElement: string[];
    TagElement: string[];
    TagsElement: string[];
    /**
     * Binding elements.
     */
    AmqpChannelBindingElement: string[];
    AmqpMessageBindingElement: string[];
    AmqpOperationBindingElement: string[];
    AmqpServerBindingElement: string[];
    Amqp1ChannelBindingElement: string[];
    Amqp1MessageBindingElement: string[];
    Amqp1OperationBindingElement: string[];
    Amqp1ServerBindingElement: string[];
    AnypointmqChannelBindingElement: string[];
    AnypointmqMessageBindingElement: string[];
    AnypointmqOperationBindingElement: string[];
    AnypointmqServerBindingElement: string[];
    GooglepubsubChannelBindingElement: string[];
    GooglepubsubMessageBindingElement: string[];
    GooglepubsubOperationBindingElement: string[];
    GooglepubsubServerBindingElement: string[];
    HttpChannelBindingElement: string[];
    HttpMessageBindingElement: string[];
    HttpOperationBindingElement: string[];
    HttpServerBindingElement: string[];
    IbmmqChannelBindingElement: string[];
    IbmmqMessageBindingElement: string[];
    IbmmqChannelOperationElement: string[];
    IbmmqServerBindingElement: string[];
    JmsChannelBindingElement: string[];
    JmsMessageBindingElement: string[];
    JmsOperationBindingElement: string[];
    JmsServerBindingElement: string[];
    KafkaChannelBindingElement: string[];
    KafkaMessageBindingElement: string[];
    KafkaOperationBindingElement: string[];
    KafkaServerBindingElement: string[];
    MercureChannelBindingElement: string[];
    MercureMessageBindingElement: string[];
    MercureOperationBindingElement: string[];
    MercureServerBindingElement: string[];
    MqttChannelBindingElement: string[];
    MqttMessageBindingElement: string[];
    MqttOperationBindingElement: string[];
    MqttServerBindingElement: string[];
    Mqtt5ChannelBindingElement: string[];
    Mqtt5MessageBindingElement: string[];
    Mqtt5OperationBindingElement: string[];
    Mqtt5ServerBindingElement: string[];
    NatsChannelBindingElement: string[];
    NatsMessageBindingElement: string[];
    NatsOperationBindingElement: string[];
    NatsServerBindingElement: string[];
    PulsarChannelBindingElement: string[];
    PulsarMessageBindingElement: string[];
    PulsarOperationBindingElement: string[];
    PulsarServerBindingElement: string[];
    RedisChannelBindingElement: string[];
    RedisMessageBindingElement: string[];
    RedisOperationBindingElement: string[];
    RedisServerBindingElement: string[];
    SnsChannelBindingElement: string[];
    SnsMessageBindingElement: string[];
    SnsOperationBindingElement: string[];
    SnsServerBindingElement: string[];
    SolaceChannelBindingElement: string[];
    SolaceMessageBindingElement: string[];
    SolaceOperationBindingElement: string[];
    SolaceServerBindingElement: string[];
    SqsChannelBindingElement: string[];
    SqsMessageBindingElement: string[];
    SqsOperationBindingElement: string[];
    SqsServerBindingElement: string[];
    StompChannelBindingElement: string[];
    StompMessageBindingElement: string[];
    StompOperationBindingElement: string[];
    StompServerBindingElement: string[];
    WebSocketChannelBindingElement: string[];
    WebSocketMessageBindingElement: string[];
    WebSocketOperationBindingElement: string[];
    WebSocketServerBindingElement: string[];
};

/**
 * @public
 */
export declare class LicenseElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get name(): StringElement | undefined;
    set name(name: StringElement | undefined);
    get url(): StringElement | undefined;
    set url(url: StringElement | undefined);
}

/**
 * @public
 */
export declare class LicenseVisitor extends LicenseVisitor_base {
    readonly element: LicenseElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'License']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: LicenseVisitorOptions);
}

declare const LicenseVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface LicenseVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MapVisitor extends PatternedFieldsVisitor {
    constructor(options: MapVisitorOptions);
}

/**
 * @public
 */
export declare interface MapVisitorOptions extends PatternedFieldsVisitorOptions {
}

/**
 * @public
 */
export declare const mediaTypes: AsyncAPIMediaTypes;

/**
 * @public
 */
export declare class MercureChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MercureChannelBindingVisitor extends MercureChannelBindingVisitor_base {
    readonly element: MercureChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mercure',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MercureChannelBindingVisitorOptions);
}

declare const MercureChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MercureChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MercureMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MercureMessageBindingVisitor extends MercureMessageBindingVisitor_base {
    readonly element: MercureMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mercure',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MercureMessageBindingVisitorOptions);
}

declare const MercureMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MercureMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MercureOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MercureOperationBindingVisitor extends MercureOperationBindingVisitor_base {
    readonly element: MercureOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mercure',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MercureOperationBindingVisitorOptions);
}

declare const MercureOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MercureOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MercureServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MercureServerBindingVisitor extends MercureServerBindingVisitor_base {
    readonly element: MercureServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mercure',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MercureServerBindingVisitorOptions);
}

declare const MercureServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MercureServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageBindingsElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get http(): HttpMessageBindingElement | undefined;
    set http(http: HttpMessageBindingElement | undefined);
    get ws(): WebSocketMessageBindingElement | undefined;
    set ws(ws: WebSocketMessageBindingElement | undefined);
    get kafka(): KafkaMessageBindingElement | undefined;
    set kafka(kafka: KafkaMessageBindingElement | undefined);
    get anypointmq(): AnypointmqMessageBindingElement | undefined;
    set anypointmq(anypointmq: AnypointmqMessageBindingElement | undefined);
    get amqp(): AmqpMessageBindingElement | undefined;
    set amqp(amqp: AmqpMessageBindingElement | undefined);
    get amqp1(): Amqp1MessageBindingElement | undefined;
    set amqp1(amqp1: Amqp1MessageBindingElement | undefined);
    get mqtt(): MqttMessageBindingElement | undefined;
    set mqtt(mqtt: MqttMessageBindingElement | undefined);
    get mqtt5(): Mqtt5MessageBindingElement | undefined;
    set mqtt5(mqtt5: Mqtt5MessageBindingElement | undefined);
    get nats(): NatsMessageBindingElement | undefined;
    set nats(nats: NatsMessageBindingElement | undefined);
    get jms(): JmsMessageBindingElement | undefined;
    set jms(jms: JmsMessageBindingElement | undefined);
    get sns(): SnsMessageBindingElement | undefined;
    set sns(sns: SnsMessageBindingElement | undefined);
    get solace(): SolaceMessageBindingElement | undefined;
    set solace(solace: SolaceMessageBindingElement | undefined);
    get sqs(): SqsMessageBindingElement | undefined;
    set sqs(sqs: SqsMessageBindingElement | undefined);
    get stomp(): StompMessageBindingElement | undefined;
    set stomp(stomp: StompMessageBindingElement | undefined);
    get redis(): RedisMessageBindingElement | undefined;
    set redis(redis: RedisMessageBindingElement | undefined);
    get mercure(): MercureMessageBindingElement | undefined;
    set mercure(mercure: MercureMessageBindingElement | undefined);
    get googlepubsub(): GooglepubsubMessageBindingElement | undefined;
    set googlepubsub(googlepubsub: GooglepubsubMessageBindingElement | undefined);
    get ibmmq(): IbmmqMessageBindingElement | undefined;
    set ibmmq(ibmmq: IbmmqMessageBindingElement | undefined);
}

/**
 * @public
 */
export declare class MessageBindingsFieldVisitor extends BindingsVisitor_base_5 {
    constructor(options: MessageBindingsFieldVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface MessageBindingsFieldVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageBindingsVisitor extends MessageBindingsVisitor_base_2 {
    readonly element: MessageBindingsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'MessageBindings']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: MessageBindingsVisitorOptions);
}

declare const MessageBindingsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

declare const MessageBindingsVisitor_base_2: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MessageBindingsVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageCorrelationIdVisitor extends CorrelationIdVisitor_base {
    constructor(options: MessageCorrelationIdVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface MessageCorrelationIdVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get messageId(): StringElement | undefined;
    set messageId(messageId: StringElement | undefined);
    get headers(): SchemaElement | ReferenceElement | undefined;
    set headers(headers: SchemaElement | ReferenceElement | undefined);
    get payload(): SchemaElement | ReferenceElement | Element | undefined;
    set payload(payload: SchemaElement | ReferenceElement | Element | undefined);
    get correlationId(): CorrelationIDElement | ReferenceElement | undefined;
    set correlationId(correlationId: CorrelationIDElement | ReferenceElement | undefined);
    get schemaFormat(): StringElement;
    set schemaFormat(schemaFormat: StringElement);
    get contentType(): StringElement;
    set contentType(contentType: StringElement);
    get name(): StringElement;
    set name(name: StringElement);
    get title(): StringElement;
    set title(title: StringElement);
    get summary(): StringElement;
    set summary(summary: StringElement);
    get description(): StringElement;
    set description(description: StringElement);
    get tags(): TagsElement | undefined;
    set tags(tags: TagsElement | undefined);
    get externalDocs(): ExternalDocumentationElement | undefined;
    set externalDocs(externalDocs: ExternalDocumentationElement | undefined);
    get bindings(): MessageBindingsElement | ReferenceElement | undefined;
    set bindings(bindings: MessageBindingsElement | ReferenceElement | undefined);
    get examples(): ArrayElement | undefined;
    set examples(examples: ArrayElement | undefined);
    get traits(): ArrayElement | undefined;
    set traits(traits: ArrayElement | undefined);
}

/**
 * @public
 */
export declare class MessageExampleElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get headers(): ObjectElement | undefined;
    set headers(headers: ObjectElement | undefined);
    get payload(): Element | undefined;
    set payload(payload: Element | undefined);
    get name(): StringElement | undefined;
    set name(name: StringElement | undefined);
    get summary(): StringElement | undefined;
    set summary(summary: StringElement | undefined);
}

/**
 * @public
 */
export declare class MessageExamplesElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MessageExamplesVisitor extends ExamplesVisitor_base {
    readonly element: MessageExamplesElement;
    constructor(options: MessageExamplesVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

/**
 * @public
 */
export declare interface MessageExamplesVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageExampleVisitor extends MessageExampleVisitor_base {
    readonly element: MessageExampleElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'MessageExample']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: MessageExampleVisitorOptions);
}

declare const MessageExampleVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MessageExampleVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageHeadersVisitor extends HeadersVisitor_base {
    constructor(options: MessageHeadersVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface MessageHeadersVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

declare const MessagesVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class MessageTraitBindingsVisitor extends BindingsVisitor_base_6 {
    constructor(options: MessageTraitBindingsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface MessageTraitBindingsVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageTraitCorrelationIdVisitor extends CorrelationIdVisitor_base_2 {
    constructor(options: MessageTraitCorrelationIdVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface MessageTraitCorrelationIdVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageTraitElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get messageId(): StringElement | undefined;
    set messageId(messageId: StringElement | undefined);
    get headers(): SchemaElement | ReferenceElement | undefined;
    set headers(headers: SchemaElement | ReferenceElement | undefined);
    get correlationId(): CorrelationIDElement | ReferenceElement | undefined;
    set correlationId(correlationId: CorrelationIDElement | ReferenceElement | undefined);
    get schemaFormat(): StringElement | undefined;
    set schemaFormat(schemaFormat: StringElement | undefined);
    get contentType(): StringElement | undefined;
    set contentType(contentType: StringElement | undefined);
    get name(): StringElement | undefined;
    set name(name: StringElement | undefined);
    get title(): StringElement | undefined;
    set title(title: StringElement | undefined);
    get summary(): StringElement | undefined;
    set summary(summary: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get tags(): TagsElement | undefined;
    set tags(tags: TagsElement | undefined);
    get externalDocs(): ExternalDocumentationElement | undefined;
    set externalDocs(externalDocs: ExternalDocumentationElement | undefined);
    get bindings(): MessageBindingsElement | ReferenceElement | undefined;
    set bindings(bindings: MessageBindingsElement | ReferenceElement | undefined);
    get examples(): ArrayElement | undefined;
    set examples(examples: ArrayElement | undefined);
}

/**
 * @public
 */
export declare class MessageTraitExamplesElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MessageTraitExamplesVisitor extends ExamplesVisitor_base_2 {
    readonly element: MessageTraitExamplesElement;
    constructor(options: MessageTraitExamplesVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

/**
 * @public
 */
export declare interface MessageTraitExamplesVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageTraitHeadersVisitor extends DefaultVisitor_base {
    constructor(options: MessageTraitHeadersVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface MessageTraitHeadersVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageTraitsElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MessageTraitsVisitor extends TraitsVisitor_base_2 {
    readonly element: MessageTraitsElement;
    constructor(options: MessageTraitsVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

declare const MessageTraitsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MessageTraitsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageTraitVisitor extends MessageTraitVisitor_base {
    readonly element: MessageTraitElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'MessageTrait']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: MessageTraitVisitorOptions);
}

declare const MessageTraitVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MessageTraitVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MessageVisitor extends MessageVisitor_base_2 {
    readonly element: MessageElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Message']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: MessageVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

declare const MessageVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

declare const MessageVisitor_base_2: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * Implementation of refracting according `schemaFormat` fixed field is now limited,
 * and currently only supports `AsyncAPI Schema Object >= 2.0.0 <=2.6.0.`
 * @public
 */
export declare interface MessageVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MixedFieldsVisitor extends MixedFieldsVisitor_base {
    protected specPathFixedFields: SpecPath;
    protected specPathPatternedFields: SpecPath;
    constructor({ specPathFixedFields, specPathPatternedFields, ...rest }: MixedFieldsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

declare const MixedFieldsVisitor_base: Class<any[], FixedFieldsVisitor & PatternedFieldsVisitor, typeof FixedFieldsVisitor & typeof PatternedFieldsVisitor>;

/**
 * @public
 */
export declare interface MixedFieldsVisitorOptions extends FixedFieldsVisitorOptions, PatternedFieldsVisitorOptions {
    readonly specPathFixedFields: SpecPath;
    readonly specPathPatternedFields: SpecPath;
}

/**
 * @public
 */
export declare class Mqtt5ChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Mqtt5ChannelBindingVisitor extends Mqtt5ChannelBindingVisitor_base {
    readonly element: Mqtt5ChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt5',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Mqtt5ChannelBindingVisitorOptions);
}

declare const Mqtt5ChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Mqtt5ChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class Mqtt5MessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Mqtt5MessageBindingVisitor extends Mqtt5MessageBindingVisitor_base {
    readonly element: Mqtt5MessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt5',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Mqtt5MessageBindingVisitorOptions);
}

declare const Mqtt5MessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Mqtt5MessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class Mqtt5OperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Mqtt5OperationBindingVisitor extends Mqtt5OperationBindingVisitor_base {
    readonly element: Mqtt5OperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt5',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Mqtt5OperationBindingVisitorOptions);
}

declare const Mqtt5OperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Mqtt5OperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class Mqtt5ServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class Mqtt5ServerBindingVisitor extends Mqtt5ServerBindingVisitor_base {
    readonly element: Mqtt5ServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt5',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Mqtt5ServerBindingVisitorOptions);
}

declare const Mqtt5ServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface Mqtt5ServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MqttChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class MqttChannelBindingVisitor extends MqttChannelBindingVisitor_base {
    readonly element: MqttChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MqttChannelBindingVisitorOptions);
}

declare const MqttChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MqttChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MqttMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class MqttMessageBindingVisitor extends MqttMessageBindingVisitor_base {
    readonly element: MqttMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MqttMessageBindingVisitorOptions);
}

declare const MqttMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MqttMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MqttOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get qos(): NumberElement | undefined;
    set qos(qos: NumberElement | undefined);
    get retain(): BooleanElement | undefined;
    set retain(retain: BooleanElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class MqttOperationBindingVisitor extends MqttOperationBindingVisitor_base {
    readonly element: MqttOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MqttOperationBindingVisitorOptions);
}

declare const MqttOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MqttOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class MqttServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get clientId(): StringElement | undefined;
    set clientId(clientId: StringElement | undefined);
    get cleanSession(): BooleanElement | undefined;
    set cleanSession(cleanSession: BooleanElement | undefined);
    get lastWill(): ObjectElement | undefined;
    set lastWill(lastWill: ObjectElement | undefined);
    get keepAlive(): NumberElement | undefined;
    set keepAlive(keepAlive: NumberElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class MqttServerBindingVisitor extends MqttServerBindingVisitor_base {
    readonly element: MqttServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MqttServerBindingVisitorOptions);
}

declare const MqttServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface MqttServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class NatsChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class NatsChannelBindingVisitor extends NatsChannelBindingVisitor_base {
    readonly element: NatsChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'nats',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: NatsChannelBindingVisitorOptions);
}

declare const NatsChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface NatsChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class NatsMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class NatsMessageBindingVisitor extends NatsMessageBindingVisitor_base {
    readonly element: NatsMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'nats',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: NatsMessageBindingVisitorOptions);
}

declare const NatsMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface NatsMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class NatsOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get queue(): StringElement | undefined;
    set queue(queue: StringElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class NatsOperationBindingVisitor extends NatsOperationBindingVisitor_base {
    readonly element: NatsOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'nats',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: NatsOperationBindingVisitorOptions);
}

declare const NatsOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface NatsOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class NatsServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class NatsServerBindingVisitor extends NatsServerBindingVisitor_base {
    readonly element: NatsServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'nats',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: NatsServerBindingVisitorOptions);
}

declare const NatsServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface NatsServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OAuthFlowElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get authorizationUrl(): StringElement | undefined;
    set authorizationUrl(authorizationUrl: StringElement | undefined);
    get tokenUrl(): StringElement | undefined;
    set tokenUrl(tokenUrl: StringElement | undefined);
    get refreshUrl(): StringElement | undefined;
    set refreshUrl(refreshUrl: StringElement | undefined);
    get scopes(): ObjectElement | undefined;
    set scopes(scopes: ObjectElement | undefined);
}

/**
 * @public
 */
export declare class OAuthFlowScopesElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class OAuthFlowScopesVisitor extends ScopesVisitor_base {
    readonly element: OAuthFlowScopesElement;
    protected readonly specPath: SpecPath<['value']>;
    constructor(options: OAuthFlowScopesVisitorOptions);
}

/**
 * @public
 */
export declare interface OAuthFlowScopesVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OAuthFlowsElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get implicit(): OAuthFlowElement | undefined;
    set implicit(implicit: OAuthFlowElement | undefined);
    get password(): OAuthFlowElement | undefined;
    set password(password: OAuthFlowElement | undefined);
    get clientCredentials(): OAuthFlowElement | undefined;
    set clientCredentials(clientCredentials: OAuthFlowElement | undefined);
    get authorizationCode(): OAuthFlowElement | undefined;
    set authorizationCode(authorizationCode: OAuthFlowElement | undefined);
}

/**
 * @public
 */
export declare class OAuthFlowsVisitor extends OAuthFlowsVisitor_base {
    readonly element: OAuthFlowsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'OAuthFlows']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: OAuthFlowsVisitorOptions);
}

declare const OAuthFlowsVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface OAuthFlowsVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OAuthFlowVisitor extends OAuthFlowVisitor_base {
    readonly element: OAuthFlowElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'OAuthFlow']>;
    constructor(options: OAuthFlowVisitorOptions);
}

declare const OAuthFlowVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface OAuthFlowVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationBindingsElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get http(): HttpOperationBindingElement | undefined;
    set http(http: HttpOperationBindingElement | undefined);
    get ws(): WebSocketOperationBindingElement | undefined;
    set ws(ws: WebSocketOperationBindingElement | undefined);
    get kafka(): KafkaOperationBindingElement | undefined;
    set kafka(kafka: KafkaOperationBindingElement | undefined);
    get anypointmq(): AnypointmqOperationBindingElement | undefined;
    set anypointmq(anypointmq: AnypointmqOperationBindingElement | undefined);
    get amqp(): AmqpOperationBindingElement | undefined;
    set amqp(amqp: AmqpOperationBindingElement | undefined);
    get amqp1(): Amqp1OperationBindingElement | undefined;
    set amqp1(amqp1: Amqp1OperationBindingElement | undefined);
    get mqtt(): MqttOperationBindingElement | undefined;
    set mqtt(mqtt: MqttOperationBindingElement | undefined);
    get mqtt5(): Mqtt5OperationBindingElement | undefined;
    set mqtt5(mqtt5: Mqtt5OperationBindingElement | undefined);
    get nats(): NatsOperationBindingElement | undefined;
    set nats(nats: NatsOperationBindingElement | undefined);
    get jms(): JmsOperationBindingElement | undefined;
    set jms(jms: JmsOperationBindingElement | undefined);
    get sns(): SnsOperationBindingElement | undefined;
    set sns(sns: SnsOperationBindingElement | undefined);
    get solace(): SolaceOperationBindingElement | undefined;
    set solace(solace: SolaceOperationBindingElement | undefined);
    get sqs(): SqsOperationBindingElement | undefined;
    set sqs(sqs: SqsOperationBindingElement | undefined);
    get stomp(): StompOperationBindingElement | undefined;
    set stomp(stomp: StompOperationBindingElement | undefined);
    get redis(): RedisOperationBindingElement | undefined;
    set redis(redis: RedisOperationBindingElement | undefined);
    get mercure(): MercureOperationBindingElement | undefined;
    set mercure(mercure: MercureOperationBindingElement | undefined);
    get googlepubsub(): GooglepubsubOperationBindingElement | undefined;
    set googlepubsub(googlepubsub: GooglepubsubOperationBindingElement | undefined);
    get ibmmq(): IbmmqOperationBindingElement | undefined;
    set ibmmq(ibmmq: IbmmqOperationBindingElement | undefined);
}

/**
 * @public
 */
export declare class OperationBindingsFieldVisitor extends BindingsVisitor_base_3 {
    constructor(options: OperationBindingsFieldVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface OperationBindingsFieldVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationBindingsVisitor extends OperationBindingsVisitor_base_2 {
    readonly element: OperationBindingsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'OperationBindings']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: OperationBindingsVisitorOptions);
}

declare const OperationBindingsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

declare const OperationBindingsVisitor_base_2: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface OperationBindingsVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get operationId(): StringElement | undefined;
    set operationId(operationId: StringElement | undefined);
    get summary(): StringElement | undefined;
    set summary(summary: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get security(): ArrayElement | undefined;
    set security(security: ArrayElement | undefined);
    get tags(): TagsElement | undefined;
    set tags(tags: TagsElement | undefined);
    get externalDocs(): ExternalDocumentationElement | undefined;
    set externalDocs(externalDocs: ExternalDocumentationElement | undefined);
    get bindings(): OperationBindingsElement | ReferenceElement | undefined;
    set bindings(bindings: OperationBindingsElement | ReferenceElement | undefined);
    get traits(): ArrayElement | undefined;
    set traits(traits: ArrayElement | undefined);
    get message(): MessageElement | ReferenceElement | ObjectElement | undefined;
    set message(message: MessageElement | ReferenceElement | ObjectElement | undefined);
}

/**
 * @public
 */
export declare class OperationMessageElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class OperationMessageMapElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get oneOf(): ArrayElement | undefined;
    set oneOf(oneOf: ArrayElement | undefined);
}

/**
 * @public
 */
export declare class OperationMessageVisitor extends MessageVisitor_base {
    element: OperationMessageMapElement;
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface OperationMessageVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationSecurityElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class OperationSecurityVisitor extends SecurityVisitor_base_2 {
    readonly element: OperationSecurityElement;
    constructor(options: OperationSecurityVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

/**
 * @public
 */
export declare interface OperationSecurityVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationTraitBindingsVisitor extends BindingsVisitor_base_4 {
    constructor(options: OperationTraitBindingsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface OperationTraitBindingsVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationTraitElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get operationId(): StringElement | undefined;
    set operationId(operationId: StringElement | undefined);
    get summary(): StringElement | undefined;
    set summary(summary: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get security(): ArrayElement | undefined;
    set security(security: ArrayElement | undefined);
    get tags(): TagsElement | undefined;
    set tags(tags: TagsElement | undefined);
    get externalDocs(): ExternalDocumentationElement | undefined;
    set externalDocs(externalDocs: ExternalDocumentationElement | undefined);
    get bindings(): OperationBindingsElement | ReferenceElement | undefined;
    set bindings(bindings: OperationBindingsElement | ReferenceElement | undefined);
}

/**
 * @public
 */
export declare class OperationTraitSecurityElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class OperationTraitSecurityVisitor extends SecurityVisitor_base_3 {
    readonly element: OperationTraitSecurityElement;
    constructor(options: OperationTraitSecurityVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

/**
 * @public
 */
export declare interface OperationTraitSecurityVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationTraitsElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class OperationTraitsVisitor extends TraitsVisitor_base {
    readonly element: OperationTraitsElement;
    constructor(options: OperationTraitsVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

declare const OperationTraitsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface OperationTraitsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationTraitVisitor extends OperationTraitVisitor_base {
    readonly element: OperationTraitElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'OperationTrait']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: OperationTraitVisitorOptions);
}

declare const OperationTraitVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface OperationTraitVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class OperationVisitor extends OperationVisitor_base {
    readonly element: OperationElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Operation']>;
    constructor(options: OperationVisitorOptions);
}

declare const OperationVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface OperationVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ParameterElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get schema(): SchemaElement | ReferenceElement | undefined;
    set schema(schema: SchemaElement | ReferenceElement | undefined);
    get location(): StringElement | undefined;
    set location(location: StringElement | undefined);
}

/**
 * @public
 */
export declare class ParameterSchemaVisitor extends SchemaVisitor_base_2 {
    constructor(options: ParameterSchemaVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ParameterSchemaVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ParametersElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ParametersVisitor extends ParametersVisitor_base_2 {
    readonly element: ParametersElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Parameter'] | ['value']>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: ParametersVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

declare const ParametersVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

declare const ParametersVisitor_base_2: Class<any[], PatternedFieldsVisitor & FallbackVisitor, typeof PatternedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ParametersVisitorOptions extends PatternedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ParameterVisitor extends ParameterVisitor_base {
    readonly element: ParameterElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Parameter']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ParameterVisitorOptions);
}

declare const ParameterVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ParameterVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class PatternedFieldsVisitor extends SpecificationVisitor {
    protected specPath: SpecPath;
    protected ignoredFields: string[];
    protected fieldPatternPredicate: (value: unknown) => boolean;
    protected canSupportSpecificationExtensions: boolean;
    protected specificationExtensionPredicate: (element: MemberElement) => boolean;
    constructor({ specPath, ignoredFields, fieldPatternPredicate, canSupportSpecificationExtensions, specificationExtensionPredicate, ...rest }: PatternedFieldsVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface PatternedFieldsVisitorOptions extends SpecificationVisitorOptions {
    readonly specPath: SpecPath;
    readonly ignoredFields?: string[];
    readonly fieldPatternPredicate?: (...args: unknown[]) => boolean;
    readonly canSupportSpecificationExtensions?: boolean;
    readonly specificationExtensionPredicate?: typeof isAsyncApiExtension;
}

/**
 * @public
 */
export declare class PulsarChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get namespace(): StringElement | undefined;
    set namespace(namespace: StringElement | undefined);
    get persistence(): StringElement | undefined;
    set persistence(persistence: StringElement | undefined);
    get compaction(): NumberElement | undefined;
    set compaction(compaction: NumberElement | undefined);
    get ['geo-replication'](): ArrayElement | undefined;
    set ['geo-replication'](geoReplication: ArrayElement | undefined);
    get retention(): ObjectElement | undefined;
    set retention(retention: ObjectElement | undefined);
    get ttl(): NumberElement | undefined;
    set ttl(ttl: NumberElement | undefined);
    get deduplication(): BooleanElement | undefined;
    set deduplication(deduplication: BooleanElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class PulsarChannelBindingVisitor extends PulsarChannelBindingVisitor_base {
    readonly element: PulsarChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'pulsar',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: PulsarChannelBindingVisitorOptions);
}

declare const PulsarChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface PulsarChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class PulsarMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class PulsarMessageBindingVisitor extends PulsarMessageBindingVisitor_base {
    readonly element: PulsarMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'pulsar',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: PulsarMessageBindingVisitorOptions);
}

declare const PulsarMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface PulsarMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class PulsarOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class PulsarOperationBindingVisitor extends PulsarOperationBindingVisitor_base {
    readonly element: PulsarOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'pulsar',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: PulsarOperationBindingVisitorOptions);
}

declare const PulsarOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface PulsarOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class PulsarServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get tenant(): StringElement | undefined;
    set tenant(tenant: StringElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class PulsarServerBindingVisitor extends PulsarServerBindingVisitor_base {
    readonly element: PulsarServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'pulsar',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: PulsarServerBindingVisitorOptions);
}

declare const PulsarServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface PulsarServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class RedisChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class RedisChannelBindingVisitor extends RedisChannelBindingVisitor_base {
    readonly element: RedisChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'redis',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: RedisChannelBindingVisitorOptions);
}

declare const RedisChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface RedisChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class RedisMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class RedisMessageBindingVisitor extends RedisMessageBindingVisitor_base {
    readonly element: RedisMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'redis',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: RedisMessageBindingVisitorOptions);
}

declare const RedisMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface RedisMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class RedisOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class RedisOperationBindingVisitor extends RedisOperationBindingVisitor_base {
    readonly element: RedisOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'redis',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: RedisOperationBindingVisitorOptions);
}

declare const RedisOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface RedisOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class RedisServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class RedisServerBindingVisitor extends RedisServerBindingVisitor_base {
    readonly element: RedisServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'redis',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: RedisServerBindingVisitorOptions);
}

declare const RedisServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface RedisServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class Reference$RefVisitor extends FallbackVisitor {
    readonly element: StringElement;
    StringElement(stringElement: StringElement): {};
}

/**
 * @public
 */
export declare class ReferenceElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    set $ref($ref: StringElement | undefined);
    get $ref(): StringElement | undefined;
}

/**
 * @public
 */
export declare interface ReferenceLikeElement extends ObjectElement_2 {
    hasKey: (value: '$ref') => true;
}

/**
 * @public
 */
export declare class ReferenceVisitor extends ReferenceVisitor_base {
    readonly element: ReferenceElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Reference']>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: ReferenceVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

declare const ReferenceVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ReferenceVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare const refractorPluginReplaceEmptyElement: () => () => {
    visitor: {
        StringElement(element: StringElement, key: any, parent: any, path: any, ancestors: any[]): any;
    };
};

/**
 * @public
 */
export declare class SchemaAllOfVisitor extends JSONSchemaAllOfVisitor {
    ArrayElement(arrayElement: ArrayElement): {};
}

export { SchemaAllOfVisitorOptions }

/**
 * @public
 */
export declare class SchemaAnyOfVisitor extends JSONSchemaAnyOfVisitor {
    ArrayElement(arrayElement: ArrayElement): {};
}

export { SchemaAnyOfVisitorOptions }

/**
 * @public
 */
export declare class SchemaDefinitionsVisitor extends JSONSchemaDefinitionsVisitor {
    ObjectElement(objectElement: ObjectElement): {};
}

export { SchemaDefinitionsVisitorOptions }

/**
 * @public
 */
export declare class SchemaDependenciesVisitor extends JSONSchemaDependenciesVisitor {
    ObjectElement(objectElement: ObjectElement): {};
}

export { SchemaDependenciesVisitorOptions }

/**
 * @public
 */
export declare class SchemaElement extends JSONSchemaElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    /**
     * Validation vocabulary
     *
     * URI: https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01
     */
    /**
     *  Validation Keywords for Applying Subschemas With Boolean Logic
     *
     *  URI: https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.7
     */
    get not(): this | BooleanElement | ReferenceElement | undefined | any;
    /**
     *  Validation Keywords for Applying Subschemas Conditionally
     *
     *  URI: https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.6
     */
    get if(): this | BooleanElement | ReferenceElement | undefined;
    set if(ifValue: this | BooleanElement | ReferenceElement | undefined);
    get then(): this | BooleanElement | ReferenceElement | undefined;
    set then(then: this | BooleanElement | ReferenceElement | undefined);
    get else(): this | BooleanElement | ReferenceElement | undefined;
    set else(elseValue: this | BooleanElement | ReferenceElement | undefined);
    /**
     * Validation Keywords for Arrays
     *
     * URI: https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.4
     */
    get items(): this | BooleanElement | ReferenceElement | ArrayElement | undefined | any;
    set items(items: this | BooleanElement | ReferenceElement | ArrayElement | undefined | any);
    get additionalItems(): this | BooleanElement | ReferenceElement | undefined;
    set additionalItems(additionalItems: this | BooleanElement | ReferenceElement | undefined);
    get containsProp(): this | BooleanElement | ReferenceElement | undefined;
    set containsProp(contains: this | BooleanElement | ReferenceElement | undefined);
    /**
     * Validation Keywords for Objects
     *
     * URI: https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.5
     */
    get propertyNames(): this | BooleanElement | ReferenceElement | undefined;
    set propertyNames(propertyNames: this | BooleanElement | ReferenceElement | undefined);
    /**
     * AsyncAPI vocabulary
     *
     * URI: https://github.com/asyncapi/spec/blob/master/spec/asyncapi.md#fixed-fields-21
     */
    get discriminator(): StringElement | undefined;
    get externalDocs(): ExternalDocumentationElement | undefined;
    get deprecated(): BooleanElement | undefined;
}

/**
 * @public
 */
export declare class SchemaItemsVisitor extends JSONSchemaItemsVisitor {
    ObjectElement(objectElement: ObjectElement): {};
    ArrayElement(arrayElement: ArrayElement): {};
}

export { SchemaItemsVisitorOptions }

/**
 * @public
 */
export declare class SchemaOneOfVisitor extends JSONSchemaOneOfVisitor {
    ArrayElement(arrayElement: ArrayElement): {};
}

export { SchemaOneOfVisitorOptions }

/**
 * @public
 */
export declare class SchemaOrReferenceVisitor extends JSONSchemaOrJSONReferenceVisitor {
    element: SchemaElement | ReferenceElement;
    enter(element: Element_2): {};
}

export { SchemaOrReferenceVisitorOptions }

/**
 * @public
 */
export declare class SchemaPatternPropertiesVisitor extends JSONSchemaPatternPropertiesVisitor {
    ObjectElement(objectElement: ObjectElement): {};
}

export { SchemaPatternPropertiesVisitorOptions }

/**
 * @public
 */
export declare class SchemaPropertiesVisitor extends JSONSchemaPropertiesVisitor {
    ObjectElement(objectElement: ObjectElement): {};
}

export { SchemaPropertiesVisitorOptions }

declare const SchemasVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class SchemaVisitor extends SchemaVisitor_base {
    element: SchemaElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Schema']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: SchemaVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
    BooleanElement(booleanElement: BooleanElement): {};
}

declare const SchemaVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

declare const SchemaVisitor_base_2: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SchemaVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

declare const ScopesVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class SecurityRequirementElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SecurityRequirementVisitor extends SecurityRequirementVisitor_base {
    readonly element: SecurityRequirementElement;
    protected readonly specPath: SpecPath<['value']>;
    constructor(options: SecurityRequirementVisitorOptions);
}

declare const SecurityRequirementVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SecurityRequirementVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SecuritySchemeElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get type(): StringElement | undefined;
    set type(type: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get name(): StringElement | undefined;
    set name(name: StringElement | undefined);
    get in(): StringElement | undefined;
    set in(inVal: StringElement | undefined);
    get scheme(): StringElement | undefined;
    set scheme(scheme: StringElement | undefined);
    get bearerFormat(): StringElement | undefined;
    set bearerFormat(bearerFormat: StringElement | undefined);
    get flows(): OAuthFlowsElement | undefined;
    set flows(flows: OAuthFlowsElement | undefined);
    get openIdConnectUrl(): StringElement | undefined;
    set openIdConnectUrl(openIdConnectUrl: StringElement | undefined);
}

declare const SecuritySchemesVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class SecuritySchemeVisitor extends SecuritySchemeVisitor_base {
    readonly element: SecuritySchemeElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'SecurityScheme']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: SecuritySchemeVisitorOptions);
}

declare const SecuritySchemeVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SecuritySchemeVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

declare const SecurityVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

declare const SecurityVisitor_base_2: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

declare const SecurityVisitor_base_3: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class ServerBindingsElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get http(): HttpServerBindingElement | undefined;
    set http(http: HttpServerBindingElement | undefined);
    get ws(): WebSocketServerBindingElement | undefined;
    set ws(ws: WebSocketServerBindingElement | undefined);
    get kafka(): KafkaServerBindingElement | undefined;
    set kafka(kafka: KafkaServerBindingElement | undefined);
    get anypointmq(): AnypointmqServerBindingElement | undefined;
    set anypointmq(anypointmq: AnypointmqServerBindingElement | undefined);
    get amqp(): AmqpServerBindingElement | undefined;
    set amqp(amqp: AmqpServerBindingElement | undefined);
    get amqp1(): Amqp1ServerBindingElement | undefined;
    set amqp1(amqp1: Amqp1ServerBindingElement | undefined);
    get mqtt(): MqttServerBindingElement | undefined;
    set mqtt(mqtt: MqttServerBindingElement | undefined);
    get mqtt5(): Mqtt5ServerBindingElement | undefined;
    set mqtt5(mqtt5: Mqtt5ServerBindingElement | undefined);
    get nats(): NatsServerBindingElement | undefined;
    set nats(nats: NatsServerBindingElement | undefined);
    get jms(): JmsServerBindingElement | undefined;
    set jms(jms: JmsServerBindingElement | undefined);
    get sns(): SnsServerBindingElement | undefined;
    set sns(sns: SnsServerBindingElement | undefined);
    get solace(): SolaceServerBindingElement | undefined;
    set solace(solace: SolaceServerBindingElement | undefined);
    get sqs(): SqsServerBindingElement | undefined;
    set sqs(sqs: SqsServerBindingElement | undefined);
    get stomp(): StompServerBindingElement | undefined;
    set stomp(stomp: StompServerBindingElement | undefined);
    get redis(): RedisServerBindingElement | undefined;
    set redis(redis: RedisServerBindingElement | undefined);
    get mercure(): MercureServerBindingElement | undefined;
    set mercure(mercure: MercureServerBindingElement | undefined);
    get googlepubsub(): GooglepubsubServerBindingElement | undefined;
    set googlepubsub(googlepubsub: GooglepubsubServerBindingElement | undefined);
    get ibmmq(): IbmmqServerBindingElement | undefined;
    set ibmmq(ibmmq: IbmmqServerBindingElement | undefined);
}

/**
 * @public
 */
export declare class ServerBindingsFieldVisitor extends BindingsVisitor_base {
    constructor(options: ServerBindingsFieldVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

/**
 * @public
 */
export declare interface ServerBindingsFieldVisitorOptions extends AlternatingVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ServerBindingsVisitor extends ServerBindingsVisitor_base_2 {
    readonly element: ServerBindingsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ServerBindings']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ServerBindingsVisitorOptions);
}

declare const ServerBindingsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

declare const ServerBindingsVisitor_base_2: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ServerBindingsVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ServerElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get url(): StringElement | undefined;
    set url(url: StringElement | undefined);
    get protocol(): StringElement | undefined;
    set protocol(protocol: StringElement | undefined);
    get protocolVersion(): StringElement | undefined;
    set protocolVersion(protocolVersion: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get variables(): ObjectElement | undefined;
    set variables(variables: ObjectElement | undefined);
    get tags(): ArrayElement | undefined;
    set tags(tags: ArrayElement | undefined);
    get security(): ArrayElement | undefined;
    set security(security: ArrayElement | undefined);
    get bindings(): ServerBindingsElement | undefined;
    set bindings(bindings: ServerBindingsElement | undefined);
}

/**
 * @public
 */
export declare class ServerSecurityElement extends ArrayElement {
    static primaryClass: string;
    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ServerSecurityVisitor extends SecurityVisitor_base {
    readonly element: ServerSecurityElement;
    constructor(options: ServerSecurityVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

/**
 * @public
 */
export declare interface ServerSecurityVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ServersElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ServersVisitor extends ServersVisitor_base {
    readonly element: ServersElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Server']>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: ServersVisitorOptions);
    ObjectElement(objectElement: ObjectElement): {};
}

declare const ServersVisitor_base: Class<any[], PatternedFieldsVisitor & FallbackVisitor, typeof PatternedFieldsVisitor & typeof FallbackVisitor>;

declare const ServersVisitor_base_2: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

declare const ServersVisitor_base_3: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ServersVisitorOptions extends PatternedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ServerUrlVisitor extends FallbackVisitor {
    readonly element: StringElement;
    StringElement(stringElement: StringElement): {};
}

/**
 * @public
 */
export declare class ServerVariableElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get enum(): ArrayElement | undefined;
    set enum(value: ArrayElement | undefined);
    get default(): StringElement | undefined;
    set default(value: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get examples(): ArrayElement | undefined;
    set examples(examples: ArrayElement | undefined);
}

/**
 * @public
 */
export declare class ServerVariablesElement extends ObjectElement {
    static primaryClass: string;
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class ServerVariablesVisitor extends VariablesVisitor_base {
    readonly element: ServerVariablesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ServerVariable']>;
    constructor(options: ServerVariablesVisitorOptions);
}

declare const ServerVariablesVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ServerVariablesVisitorOptions extends MapVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ServerVariableVisitor extends ServerVariableVisitor_base {
    readonly element: ServerVariableElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ServerVariable']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ServerVariableVisitorOptions);
}

declare const ServerVariableVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ServerVariableVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class ServerVisitor extends ServerVisitor_base {
    readonly element: ServerElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Server']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ServerVisitorOptions);
}

declare const ServerVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface ServerVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SnsChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SnsChannelBindingVisitor extends SnsChannelBindingVisitor_base {
    readonly element: SnsChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sns',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SnsChannelBindingVisitorOptions);
}

declare const SnsChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SnsChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SnsMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SnsMessageBindingVisitor extends SnsMessageBindingVisitor_base {
    readonly element: SnsMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sns',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SnsMessageBindingVisitorOptions);
}

declare const SnsMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SnsMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SnsOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SnsOperationBindingVisitor extends SnsOperationBindingVisitor_base {
    readonly element: SnsOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sns',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SnsOperationBindingVisitorOptions);
}

declare const SnsOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SnsOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SnsServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SnsServerBindingVisitor extends SnsServerBindingVisitor_base {
    readonly element: SnsServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sns',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SnsServerBindingVisitorOptions);
}

declare const SnsServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SnsServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SolaceChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SolaceChannelBindingVisitor extends SolaceChannelBindingVisitor_base {
    readonly element: SolaceChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'solace',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SolaceChannelBindingVisitorOptions);
}

declare const SolaceChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SolaceChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SolaceMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SolaceMessageBindingVisitor extends SolaceMessageBindingVisitor_base {
    readonly element: SolaceMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'solace',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SolaceMessageBindingVisitor);
}

declare const SolaceMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SolaceMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SolaceOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
    get destinations(): ArrayElement | undefined;
    set destinations(destinations: ArrayElement | undefined);
}

/**
 * @public
 */
export declare class SolaceOperationBindingVisitor extends SolaceOperationBindingVisitor_base {
    readonly element: SolaceOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'solace',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SolaceOperationBindingVisitorOptions);
}

declare const SolaceOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SolaceOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SolaceServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
    get msgVpn(): StringElement | undefined;
    set msgVpn(msgVpn: StringElement | undefined);
}

/**
 * @public
 */
export declare class SolaceServerBindingVisitor extends SolaceServerBindingVisitor_base {
    readonly element: SolaceServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'solace',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SolaceServerBindingVisitorOptions);
}

declare const SolaceServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SolaceServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SpecificationExtensionVisitor extends SpecificationVisitor {
    element: MemberElement;
    MemberElement(memberElement: MemberElement): {};
}

/**
 * @public
 */
export declare const specificationObj: {
    visitors: {
        value: typeof FallbackVisitor;
        document: {
            objects: {
                /**
                 * `AsyncApi >= 2.0.0 <=2.6.0` specification elements.
                 */
                AsyncApi: {
                    $visitor: typeof AsyncApi2Visitor;
                    fixedFields: {
                        asyncapi: {
                            $ref: string;
                        };
                        id: {
                            $ref: string;
                        };
                        info: {
                            $ref: string;
                        };
                        servers: {
                            $ref: string;
                        };
                        defaultContentType: {
                            $ref: string;
                        };
                        channels: {
                            $ref: string;
                        };
                        components: {
                            $ref: string;
                        };
                        tags: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                    };
                };
                AsyncApiVersion: {
                    $visitor: typeof AsyncApiVersionVisitor;
                };
                Identifier: {
                    $visitor: typeof IdentifierVisitor;
                };
                Info: {
                    $visitor: typeof InfoVisitor;
                    fixedFields: {
                        title: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        termsOfService: {
                            $ref: string;
                        };
                        version: typeof InfoVersionVisitor;
                        contact: {
                            $ref: string;
                        };
                        license: {
                            $ref: string;
                        };
                    };
                };
                Contact: {
                    $visitor: typeof ContactVisitor;
                    fixedFields: {
                        name: {
                            $ref: string;
                        };
                        url: {
                            $ref: string;
                        };
                        email: {
                            $ref: string;
                        };
                    };
                };
                License: {
                    $visitor: typeof LicenseVisitor;
                    fixedFields: {
                        name: {
                            $ref: string;
                        };
                        url: {
                            $ref: string;
                        };
                    };
                };
                Servers: {
                    $visitor: typeof ServersVisitor;
                };
                Server: {
                    $visitor: typeof ServerVisitor;
                    fixedFields: {
                        url: typeof ServerUrlVisitor;
                        protocol: {
                            $ref: string;
                        };
                        protocolVersion: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        variables: typeof ServerVariablesVisitor;
                        security: typeof ServerSecurityVisitor;
                        tags: {
                            $ref: string;
                        };
                        bindings: typeof ServerBindingsFieldVisitor;
                    };
                };
                ServerVariable: {
                    $visitor: typeof ServerVariableVisitor;
                    fixedFields: {
                        enum: {
                            $ref: string;
                        };
                        default: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        examples: {
                            $ref: string;
                        };
                    };
                };
                DefaultContentType: {
                    $visitor: typeof DefaultContentTypeVisitor;
                };
                Channels: {
                    $visitor: typeof ChannelsVisitor;
                };
                ChannelItem: {
                    $visitor: typeof ChannelItemVisitor;
                    fixedFields: {
                        $ref: typeof ChannelItem$RefVisitor;
                        description: {
                            $ref: string;
                        };
                        servers: typeof ChannelItemServersVisitor;
                        subscribe: {
                            $ref: string;
                        };
                        publish: {
                            $ref: string;
                        };
                        parameters: {
                            $ref: string;
                        };
                        bindings: typeof ChannelItemBindingsVisitor;
                    };
                };
                Operation: {
                    $visitor: typeof OperationVisitor;
                    fixedFields: {
                        operationId: {
                            $ref: string;
                        };
                        summary: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        security: typeof OperationSecurityVisitor;
                        tags: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                        bindings: typeof OperationBindingsFieldVisitor;
                        traits: typeof OperationTraitsVisitor;
                        message: typeof OperationMessageVisitor;
                    };
                };
                OperationTrait: {
                    $visitor: typeof OperationTraitVisitor;
                    fixedFields: {
                        operationId: {
                            $ref: string;
                        };
                        summary: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        security: typeof OperationTraitSecurityVisitor;
                        tags: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                        bindings: typeof OperationTraitBindingsVisitor;
                    };
                };
                Message: {
                    $visitor: typeof MessageVisitor;
                    fixedFields: {
                        messageId: {
                            $ref: string;
                        };
                        headers: typeof MessageHeadersVisitor;
                        payload: {
                            $ref: string;
                        };
                        correlationId: typeof MessageCorrelationIdVisitor;
                        schemaFormat: {
                            $ref: string;
                        };
                        contentType: {
                            $ref: string;
                        };
                        name: {
                            $ref: string;
                        };
                        title: {
                            $ref: string;
                        };
                        summary: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        tags: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                        bindings: typeof MessageBindingsFieldVisitor;
                        examples: typeof MessageExamplesVisitor;
                        traits: typeof MessageTraitsVisitor;
                    };
                };
                MessageTrait: {
                    $visitor: typeof MessageTraitVisitor;
                    fixedFields: {
                        messageId: {
                            $ref: string;
                        };
                        headers: typeof MessageTraitHeadersVisitor;
                        correlationId: typeof MessageTraitCorrelationIdVisitor;
                        schemaFormat: {
                            $ref: string;
                        };
                        contentType: {
                            $ref: string;
                        };
                        name: {
                            $ref: string;
                        };
                        title: {
                            $ref: string;
                        };
                        summary: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        tags: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                        bindings: typeof MessageTraitBindingsVisitor;
                        examples: typeof MessageTraitExamplesVisitor;
                    };
                };
                MessageExample: {
                    $visitor: typeof MessageExampleVisitor;
                    fixedFields: {
                        headers: {
                            $ref: string;
                        };
                        payload: {
                            $ref: string;
                        };
                        name: {
                            $ref: string;
                        };
                        summary: {
                            $ref: string;
                        };
                    };
                };
                Tags: {
                    $visitor: typeof TagsVisitor;
                };
                Tag: {
                    $visitor: typeof TagVisitor;
                    fixedFields: {
                        name: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                    };
                };
                ExternalDocumentation: {
                    $visitor: typeof ExternalDocumentationVisitor;
                    fixedFields: {
                        description: {
                            $ref: string;
                        };
                        url: {
                            $ref: string;
                        };
                    };
                };
                Components: {
                    $visitor: typeof ComponentsVisitor;
                    fixedFields: {
                        schemas: typeof ComponentsSchemasVisitor;
                        servers: typeof ComponentsServersVisitor;
                        serverVariables: typeof ComponentsServerVariablesVisitor;
                        channels: typeof ComponentsChannelsVisitor;
                        messages: typeof ComponentsMessagesVisitor;
                        securitySchemes: typeof ComponentsSecuritySchemesVisitor;
                        parameters: typeof ComponentsParametersVisitor;
                        correlationIds: typeof ComponentsCorrelationIdsVisitor;
                        operationTraits: typeof ComponentsOperationTraitsVisitor;
                        messageTraits: typeof ComponentsMessageTraitsVisitor;
                        serverBindings: typeof ComponentsServerBindingsVisitor;
                        channelBindings: typeof ComponentsChannelBindingsVisitor;
                        operationBindings: typeof ComponentsOperationBindingsVisitor;
                        messageBindings: typeof ComponentsMessageBindingsVisitor;
                    };
                };
                JSONReference: {
                    $visitor: typeof ReferenceVisitor;
                    fixedFields: {
                        $ref: typeof Reference$RefVisitor;
                    };
                };
                Reference: {
                    $visitor: typeof ReferenceVisitor;
                    fixedFields: {
                        $ref: typeof Reference$RefVisitor;
                    };
                };
                JSONSchema: {
                    $visitor: typeof SchemaVisitor;
                    fixedFields: {
                        allOf: typeof SchemaAllOfVisitor;
                        anyOf: typeof SchemaAnyOfVisitor;
                        oneOf: typeof SchemaOneOfVisitor;
                        items: typeof SchemaItemsVisitor;
                        properties: typeof SchemaPropertiesVisitor;
                        patternProperties: typeof SchemaPatternPropertiesVisitor;
                        dependencies: typeof SchemaDependenciesVisitor;
                        definitions: typeof SchemaDefinitionsVisitor;
                        discriminator: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                        deprecated: {
                            $ref: string;
                        };
                        base: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        required: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        type: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        default: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        id: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        media: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        title: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        pattern: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        description: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        format: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        readOnly: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        $schema: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        multipleOf: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        exclusiveMaximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        exclusiveMinimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maxLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        additionalItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maxItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        uniqueItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maxProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        additionalProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        enum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        not: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        links: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                    };
                };
                Schema: {
                    $visitor: typeof SchemaVisitor;
                    fixedFields: {
                        allOf: typeof SchemaAllOfVisitor;
                        anyOf: typeof SchemaAnyOfVisitor;
                        oneOf: typeof SchemaOneOfVisitor;
                        items: typeof SchemaItemsVisitor;
                        properties: typeof SchemaPropertiesVisitor;
                        patternProperties: typeof SchemaPatternPropertiesVisitor;
                        dependencies: typeof SchemaDependenciesVisitor;
                        definitions: typeof SchemaDefinitionsVisitor;
                        discriminator: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                        deprecated: {
                            $ref: string;
                        };
                        base: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        required: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        type: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        default: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        id: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        media: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        title: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        pattern: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        description: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        format: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        readOnly: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        $schema: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        multipleOf: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        exclusiveMaximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        exclusiveMinimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maxLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        additionalItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maxItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        uniqueItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        maxProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        minProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        additionalProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        enum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        not: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                        links: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | ItemsVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | TypeVisitor;
                    };
                };
                LinkDescription: {
                    $visitor: LinkDescriptionVisitor;
                    fixedFields: {
                        href: {
                            $ref: string;
                        };
                        rel: {
                            $ref: string;
                        };
                        title: {
                            $ref: string;
                        };
                        targetSchema: SchemaOrReferenceVisitor_2;
                        mediaType: {
                            $ref: string;
                        };
                        method: {
                            $ref: string;
                        };
                        encType: {
                            $ref: string;
                        };
                        schema: SchemaOrReferenceVisitor_2;
                    };
                };
                SecurityScheme: {
                    $visitor: typeof SecuritySchemeVisitor;
                    fixedFields: {
                        type: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        name: {
                            $ref: string;
                        };
                        in: {
                            $ref: string;
                        };
                        scheme: {
                            $ref: string;
                        };
                        bearerFormat: {
                            $ref: string;
                        };
                        flows: {
                            $ref: string;
                        };
                        openIdConnectUrl: {
                            $ref: string;
                        };
                    };
                };
                SecurityRequirement: {
                    $visitor: typeof SecurityRequirementVisitor;
                };
                OAuthFlows: {
                    $visitor: typeof OAuthFlowsVisitor;
                    fixedFields: {
                        implicit: {
                            $ref: string;
                        };
                        password: {
                            $ref: string;
                        };
                        clientCredentials: {
                            $ref: string;
                        };
                        authorizationCode: {
                            $ref: string;
                        };
                    };
                };
                OAuthFlow: {
                    $visitor: typeof OAuthFlowVisitor;
                    fixedFields: {
                        authorizationUrl: {
                            $ref: string;
                        };
                        tokenUrl: {
                            $ref: string;
                        };
                        refreshUrl: {
                            $ref: string;
                        };
                        scopes: typeof OAuthFlowScopesVisitor;
                    };
                };
                ServerBindings: {
                    $visitor: typeof ServerBindingsVisitor;
                    fixedFields: {
                        http: {
                            $ref: string;
                        };
                        ws: {
                            $ref: string;
                        };
                        kafka: {
                            $ref: string;
                        };
                        anypointmq: {
                            $ref: string;
                        };
                        amqp: {
                            $ref: string;
                        };
                        amqp1: {
                            $ref: string;
                        };
                        mqtt: {
                            $ref: string;
                        };
                        mqtt5: {
                            $ref: string;
                        };
                        nats: {
                            $ref: string;
                        };
                        jms: {
                            $ref: string;
                        };
                        sns: {
                            $ref: string;
                        };
                        solace: {
                            $ref: string;
                        };
                        sqs: {
                            $ref: string;
                        };
                        stomp: {
                            $ref: string;
                        };
                        redis: {
                            $ref: string;
                        };
                        mercure: {
                            $ref: string;
                        };
                        ibmmq: {
                            $ref: string;
                        };
                        googlepubsub: {
                            $ref: string;
                        };
                        pulsar: {
                            $ref: string;
                        };
                    };
                };
                Parameters: {
                    $visitor: typeof ParametersVisitor;
                };
                Parameter: {
                    $visitor: typeof ParameterVisitor;
                    fixedFields: {
                        description: {
                            $ref: string;
                        };
                        schema: typeof ParameterSchemaVisitor;
                        location: {
                            $ref: string;
                        };
                    };
                };
                ChannelBindings: {
                    $visitor: typeof ChannelBindingsVisitor;
                    fixedFields: {
                        http: {
                            $ref: string;
                        };
                        ws: {
                            $ref: string;
                        };
                        kafka: {
                            $ref: string;
                        };
                        anypointmq: {
                            $ref: string;
                        };
                        amqp: {
                            $ref: string;
                        };
                        amqp1: {
                            $ref: string;
                        };
                        mqtt: {
                            $ref: string;
                        };
                        mqtt5: {
                            $ref: string;
                        };
                        nats: {
                            $ref: string;
                        };
                        jms: {
                            $ref: string;
                        };
                        sns: {
                            $ref: string;
                        };
                        solace: {
                            $ref: string;
                        };
                        sqs: {
                            $ref: string;
                        };
                        stomp: {
                            $ref: string;
                        };
                        redis: {
                            $ref: string;
                        };
                        mercure: {
                            $ref: string;
                        };
                        ibmmq: {
                            $ref: string;
                        };
                        googlepubsub: {
                            $ref: string;
                        };
                        pulsar: {
                            $ref: string;
                        };
                    };
                };
                OperationBindings: {
                    $visitor: typeof OperationBindingsVisitor;
                    fixedFields: {
                        http: {
                            $ref: string;
                        };
                        ws: {
                            $ref: string;
                        };
                        kafka: {
                            $ref: string;
                        };
                        anypointmq: {
                            $ref: string;
                        };
                        amqp: {
                            $ref: string;
                        };
                        amqp1: {
                            $ref: string;
                        };
                        mqtt: {
                            $ref: string;
                        };
                        mqtt5: {
                            $ref: string;
                        };
                        nats: {
                            $ref: string;
                        };
                        jms: {
                            $ref: string;
                        };
                        sns: {
                            $ref: string;
                        };
                        solace: {
                            $ref: string;
                        };
                        sqs: {
                            $ref: string;
                        };
                        stomp: {
                            $ref: string;
                        };
                        redis: {
                            $ref: string;
                        };
                        mercure: {
                            $ref: string;
                        };
                        googlepubsub: {
                            $ref: string;
                        };
                        ibmmq: {
                            $ref: string;
                        };
                        pulsar: {
                            $ref: string;
                        };
                    };
                };
                MessageBindings: {
                    $visitor: typeof MessageBindingsVisitor;
                    fixedFields: {
                        http: {
                            $ref: string;
                        };
                        ws: {
                            $ref: string;
                        };
                        kafka: {
                            $ref: string;
                        };
                        anypointmq: {
                            $ref: string;
                        };
                        amqp: {
                            $ref: string;
                        };
                        amqp1: {
                            $ref: string;
                        };
                        mqtt: {
                            $ref: string;
                        };
                        mqtt5: {
                            $ref: string;
                        };
                        nats: {
                            $ref: string;
                        };
                        jms: {
                            $ref: string;
                        };
                        sns: {
                            $ref: string;
                        };
                        solace: {
                            $ref: string;
                        };
                        sqs: {
                            $ref: string;
                        };
                        stomp: {
                            $ref: string;
                        };
                        redis: {
                            $ref: string;
                        };
                        mercure: {
                            $ref: string;
                        };
                        ibmmq: {
                            $ref: string;
                        };
                        googlepubsub: {
                            $ref: string;
                        };
                        pulsar: {
                            $ref: string;
                        };
                    };
                };
                CorrelationID: {
                    $visitor: typeof CorrelationIDVisitor;
                    fixedFields: {
                        description: {
                            $ref: string;
                        };
                        location: {
                            $ref: string;
                        };
                    };
                };
                bindings: {
                    http: {
                        ServerBinding: {
                            $visitor: typeof HttpServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof HttpChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof HttpOperationBindingVisitor;
                            fixedFields: {
                                type: {
                                    $ref: string;
                                };
                                method: {
                                    $ref: string;
                                };
                                query: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            $visitor: typeof HttpMessageBindingVisitor;
                            fixedFields: {
                                headers: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    ws: {
                        ServerBinding: {
                            $visitor: typeof WebSocketServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof WebSocketChannelBindingVisitor;
                            fixedFields: {
                                method: {
                                    $ref: string;
                                };
                                query: typeof SchemaOrReferenceVisitor;
                                headers: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            $visitor: typeof WebSocketOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof WebSocketMessageBindingVisitor;
                        };
                    };
                    kafka: {
                        ServerBinding: {
                            $visitor: typeof KafkaServerBindingVisitor;
                            fixedFields: {
                                schemaRegistryUrl: {
                                    $ref: string;
                                };
                                schemaRegistryVendor: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            $visitor: typeof KafkaChannelBindingVisitor;
                            fixedFields: {
                                topic: {
                                    $ref: string;
                                };
                                partitions: {
                                    $ref: string;
                                };
                                replicas: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            $visitor: typeof KafkaOperationBindingVisitor;
                            fixedFields: {
                                groupId: typeof SchemaOrReferenceVisitor;
                                clientId: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            $visitor: typeof KafkaMessageBindingVisitor;
                            fixedFields: {
                                key: typeof SchemaOrReferenceVisitor;
                                schemaIdLocation: {
                                    $ref: string;
                                };
                                schemaIdPayloadEncoding: {
                                    $ref: string;
                                };
                                schemaLookupStrategy: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    anypointmq: {
                        ServerBinding: {
                            $visitor: typeof AnypointmqServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof AnypointmqChannelBindingVisitor;
                            fixedFields: {
                                destination: {
                                    $ref: string;
                                };
                                destinationType: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            $visitor: typeof AnypointmqOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof AnypointmqMessageBindingVisitor;
                            fixedFields: {
                                headers: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    amqp: {
                        ServerBinding: {
                            $visitor: typeof AmqpServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof AmqpChannelBindingVisitor;
                            fixedFields: {
                                is: {
                                    $ref: string;
                                };
                                exchange: {
                                    $ref: string;
                                };
                                queue: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            $visitor: typeof AmqpOperationBindingVisitor;
                            fixedFields: {
                                expiration: {
                                    $ref: string;
                                };
                                userId: {
                                    $ref: string;
                                };
                                cc: {
                                    $ref: string;
                                };
                                priority: {
                                    $ref: string;
                                };
                                deliveryMode: {
                                    $ref: string;
                                };
                                mandatory: {
                                    $ref: string;
                                };
                                bcc: {
                                    $ref: string;
                                };
                                replyTo: {
                                    $ref: string;
                                };
                                timestamp: {
                                    $ref: string;
                                };
                                ack: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            $visitor: typeof AmqpMessageBindingVisitor;
                            fixedFields: {
                                contentEncoding: {
                                    $ref: string;
                                };
                                messageType: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    amqp1: {
                        ServerBinding: {
                            $visitor: typeof Amqp1ServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof Amqp1ChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof Amqp1OperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof Amqp1MessageBindingVisitor;
                        };
                    };
                    mqtt: {
                        ServerBinding: {
                            $visitor: typeof MqttServerBindingVisitor;
                            fixedFields: {
                                clientId: {
                                    $ref: string;
                                };
                                cleanSession: {
                                    $ref: string;
                                };
                                lastWill: {
                                    $ref: string;
                                };
                                keepAlive: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            $visitor: typeof MqttChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof MqttOperationBindingVisitor;
                            fixedFields: {
                                qos: {
                                    $ref: string;
                                };
                                retain: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            $visitor: typeof MqttMessageBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    mqtt5: {
                        ServerBinding: {
                            $visitor: typeof Mqtt5ServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof Mqtt5ChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof Mqtt5OperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof Mqtt5MessageBindingVisitor;
                        };
                    };
                    nats: {
                        ServerBinding: {
                            $visitor: typeof NatsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof NatsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof NatsOperationBindingVisitor;
                            fixedFields: {
                                queue: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            $visitor: typeof NatsMessageBindingVisitor;
                        };
                    };
                    pulsar: {
                        ServerBinding: {
                            $visitor: typeof PulsarServerBindingVisitor;
                            fixedFields: {
                                tenant: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            $visitor: typeof PulsarChannelBindingVisitor;
                            fixedFields: {
                                namespace: {
                                    $ref: string;
                                };
                                persistence: {
                                    $ref: string;
                                };
                                compaction: {
                                    $ref: string;
                                };
                                'geo-replication': {
                                    $ref: string;
                                };
                                retention: {
                                    $ref: string;
                                };
                                ttl: {
                                    $ref: string;
                                };
                                deduplication: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            $visitor: typeof PulsarOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof PulsarMessageBindingVisitor;
                        };
                    };
                    jms: {
                        ServerBinding: {
                            $visitor: typeof JmsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof JmsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof JmsOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof JmsMessageBindingVisitor;
                        };
                    };
                    sns: {
                        ServerBinding: {
                            $visitor: typeof SnsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof SnsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof SnsOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof SnsMessageBindingVisitor;
                        };
                    };
                    solace: {
                        ServerBinding: {
                            $visitor: typeof SolaceServerBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                msgVpn: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            $visitor: typeof SolaceChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof SolaceOperationBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                destinations: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            $visitor: typeof SolaceMessageBindingVisitor;
                        };
                    };
                    sqs: {
                        ServerBinding: {
                            $visitor: typeof SqsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof SqsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof SqsOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof SqsMessageBindingVisitor;
                        };
                    };
                    stomp: {
                        ServerBinding: {
                            $visitor: typeof StompServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof StompChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof StompOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof StompMessageBindingVisitor;
                        };
                    };
                    redis: {
                        ServerBinding: {
                            $visitor: typeof RedisServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof RedisChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof RedisOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof RedisMessageBindingVisitor;
                        };
                    };
                    mercure: {
                        ServerBinding: {
                            $visitor: typeof MercureServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof MercureChannelBindingVisitor;
                        };
                        OperationBinding: {
                            $visitor: typeof MercureOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof MercureMessageBindingVisitor;
                        };
                    };
                    googlepubsub: {
                        ServerBinding: {
                            $visitor: typeof GooglepubsubServerBindingVisitor;
                        };
                        ChannelBinding: {
                            $visitor: typeof GooglepubsubChannelBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                labels: {
                                    $ref: string;
                                };
                                messageRetentionDuration: {
                                    $ref: string;
                                };
                                messageStoragePolicy: {
                                    $ref: string;
                                };
                                schemaSettings: {
                                    $ref: string;
                                };
                                topic: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            $visitor: typeof GooglepubsubOperationBindingVisitor;
                        };
                        MessageBinding: {
                            $visitor: typeof GooglepubsubMessageBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                attributes: {
                                    $ref: string;
                                };
                                orderingKey: {
                                    $ref: string;
                                };
                                schema: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    ibmmq: {
                        ServerBinding: {
                            $visitor: typeof IbmmqServerBindingVisitor;
                            fixedFields: {
                                groupId: {
                                    $ref: string;
                                };
                                ccdtQueueManagerName: {
                                    $ref: string;
                                };
                                cipherSpec: {
                                    $ref: string;
                                };
                                multiEndpointServer: {
                                    $ref: string;
                                };
                                heartBeatInterval: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            $visitor: typeof IbmmqChannelBindingVisitor;
                            fixedFields: {
                                destinationType: {
                                    $ref: string;
                                };
                                queue: {
                                    $ref: string;
                                };
                                topic: {
                                    $ref: string;
                                };
                                maxMsgLength: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            $visitor: typeof IbmmqMessageBindingVisitor;
                            fixedFields: {
                                type: {
                                    $ref: string;
                                };
                                headers: {
                                    $ref: string;
                                };
                                description: {
                                    $ref: string;
                                };
                                expiry: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            $visitor: typeof IbmmqOperationBindingVisitor;
                        };
                    };
                };
            };
            extension: {
                $visitor: typeof SpecificationExtensionVisitor;
            };
        };
    };
};

/**
 * @public
 */
export declare class SpecificationVisitor extends Visitor {
    protected readonly specObj: typeof specificationObj;
    protected readonly passingOptionsNames: string[];
    constructor({ specObj, ...rest }: SpecificationVisitorOptions);
    retrievePassingOptions(): string[];
    retrieveFixedFields(specPath: string[]): string[];
    retrieveVisitor(specPath: string[]): unknown;
    retrieveVisitorInstance(specPath: string[], options?: {}): Visitor;
    toRefractedElement(specPath: string[], element: any, options?: {}): any;
}

/**
 * This is a base Type for every visitor that does
 * internal look-ups to retrieve other child visitors.
 * @public
 */
declare interface SpecificationVisitorOptions extends VisitorOptions {
    readonly specObj: typeof specificationObj;
}
export { SpecificationVisitorOptions as SpecificationExtensionVisitorOptions }
export { SpecificationVisitorOptions }

/**
 * @public
 */
export declare type SpecPath<T = string[]> = (element: unknown) => T;

/**
 * @public
 */
export declare class SqsChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SqsChannelBindingVisitor extends SqsChannelBindingVisitor_base {
    readonly element: SqsChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sqs',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SqsChannelBindingVisitorOptions);
}

declare const SqsChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SqsChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SqsMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SqsMessageBindingVisitor extends SqsMessageBindingVisitor_base {
    readonly element: SqsMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sqs',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SqsMessageBindingVisitorOptions);
}

declare const SqsMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SqsMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SqsOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SqsOperationBindingVisitor extends SqsOperationBindingVisitor_base {
    readonly element: SqsOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sqs',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SqsOperationBindingVisitorOptions);
}

declare const SqsOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SqsOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class SqsServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class SqsServerBindingVisitor extends SqsServerBindingVisitor_base {
    readonly element: SqsServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sqs',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SqsServerBindingVisitorOptions);
}

declare const SqsServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface SqsServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class StompChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class StompChannelBindingVisitor extends StompChannelBindingVisitor_base {
    readonly element: StompChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'stomp',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: StompChannelBindingVisitorOptions);
}

declare const StompChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface StompChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class StompMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class StompMessageBindingVisitor extends StompMessageBindingVisitor_base {
    readonly element: StompMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'stomp',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: StompMessageBindingVisitorOptions);
}

declare const StompMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface StompMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class StompOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class StompOperationBindingVisitor extends StompOperationBindingVisitor_base {
    readonly element: StompOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'stomp',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: StompOperationBindingVisitorOptions);
}

declare const StompOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface StompOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class StompServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class StompServerBindingVisitor extends StompServerBindingVisitor_base {
    readonly element: StompServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'stomp',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: StompServerBindingVisitorOptions);
}

declare const StompServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface StompServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class TagElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get name(): StringElement | undefined;
    set name(name: StringElement | undefined);
    get description(): StringElement | undefined;
    set description(description: StringElement | undefined);
    get externalDocs(): ExternalDocumentationElement | undefined;
    set externalDocs(externalDocs: ExternalDocumentationElement | undefined);
}

/**
 * @public
 */
export declare class TagsElement extends ArrayElement {
    constructor(content?: unknown[], meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class TagsVisitor extends TagsVisitor_base {
    readonly element: TagsElement;
    constructor(options: TagsVisitorOptions);
    ArrayElement(arrayElement: ArrayElement): {};
}

declare const TagsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface TagsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class TagVisitor extends TagVisitor_base {
    readonly element: TagElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Tag']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: TagVisitorOptions);
}

declare const TagVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface TagVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

declare const TraitsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

declare const TraitsVisitor_base_2: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

declare const VariablesVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare class Visitor {
    element: Element_2;
    constructor(options: VisitorOptions);
    copyMetaAndAttributes(from: Element_2, to: Element_2): void;
}

/**
 * @public
 */
declare interface VisitorOptions {
}
export { VisitorOptions as ChannelItem$RefVisitorOptions }
export { VisitorOptions as FallbackVisitorOptions }
export { VisitorOptions as InfoVersionVisitorOptions }
export { VisitorOptions as Reference$RefVisitorOptions }
export { VisitorOptions as ServerUrlVisitorOptions }
export { VisitorOptions }

/**
 * @public
 */
export declare class WebSocketChannelBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
    get method(): StringElement | undefined;
    set method(method: StringElement | undefined);
    get query(): SchemaElement | ReferenceElement | undefined;
    set query(query: SchemaElement | ReferenceElement | undefined);
    get headers(): SchemaElement | ReferenceElement | undefined;
    set headers(headers: SchemaElement | ReferenceElement | undefined);
    get bindingVersion(): StringElement | undefined;
    set bindingVersion(bindingVersion: StringElement | undefined);
}

/**
 * @public
 */
export declare class WebSocketChannelBindingVisitor extends WebSocketChannelBindingVisitor_base {
    readonly element: WebSocketChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ws',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: WebSocketChannelBindingVisitorOptions);
}

declare const WebSocketChannelBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface WebSocketChannelBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class WebSocketMessageBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class WebSocketMessageBindingVisitor extends WebSocketMessageBindingVisitor_base {
    readonly element: WebSocketMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ws',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: WebSocketMessageBindingVisitorOptions);
}

declare const WebSocketMessageBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface WebSocketMessageBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class WebSocketOperationBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class WebSocketOperationBindingVisitor extends WebSocketOperationBindingVisitor_base {
    readonly element: WebSocketOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ws',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: WebSocketOperationBindingVisitor);
}

declare const WebSocketOperationBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface WebSocketOperationBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

/**
 * @public
 */
export declare class WebSocketServerBindingElement extends ObjectElement {
    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
}

/**
 * @public
 */
export declare class WebSocketServerBindingVisitor extends WebSocketServerBindingVisitor_base {
    readonly element: WebSocketServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ws',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: WebSocketServerBindingVisitorOptions);
}

declare const WebSocketServerBindingVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

/**
 * @public
 */
export declare interface WebSocketServerBindingVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
}

export { }
