import { AllOfVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { AnyOfVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { ArrayElement } from '@speclynx/apidom-datamodel';
import { Attributes } from '@speclynx/apidom-datamodel';
import { BooleanElement } from '@speclynx/apidom-datamodel';
import { Class } from 'ts-mixer/dist/types/types.js';
import { DefinitionsVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { DefinitionsVisitor as DefinitionsVisitor_2 } from '@speclynx/apidom-ns-json-schema-draft-4';
import { DependenciesVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { DependenciesVisitor as DependenciesVisitor_2 } from '@speclynx/apidom-ns-json-schema-draft-4';
import { Element as Element_2 } from '@speclynx/apidom-datamodel';
import { EnumVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
import { isBooleanJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-draft-7';
import { ItemsVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
import { JSONSchemaDraft4ItemsVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { JSONSchemaElement } from '@speclynx/apidom-ns-json-schema-draft-7';
import { LinkDescriptionVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
import { LinksVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
import { MediaTypes } from '@speclynx/apidom-core';
import { MemberElement } from '@speclynx/apidom-datamodel';
import { Meta } from '@speclynx/apidom-datamodel';
import { Namespace } from '@speclynx/apidom-datamodel';
import type { NamespacePlugin } from '@speclynx/apidom-datamodel';
import { NumberElement } from '@speclynx/apidom-datamodel';
import { ObjectElement } from '@speclynx/apidom-datamodel';
import { OneOfVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { Path } from '@speclynx/apidom-traverse';
import { PatternPropertiesVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { PatternPropertiesVisitor as PatternPropertiesVisitor_2 } from '@speclynx/apidom-ns-json-schema-draft-4';
import { PropertiesVisitor } from '@speclynx/apidom-ns-json-schema-draft-7';
import { PropertiesVisitor as PropertiesVisitor_2 } from '@speclynx/apidom-ns-json-schema-draft-4';
import { AllOfVisitorOptions as SchemaAllOfVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { AnyOfVisitorOptions as SchemaAnyOfVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { DefinitionsVisitorOptions as SchemaDefinitionsVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { DependenciesVisitorOptions as SchemaDependenciesVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { ItemsVisitorOptions as SchemaItemsVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { OneOfVisitorOptions as SchemaOneOfVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { SchemaOrReferenceVisitor as SchemaOrReferenceVisitor_2 } from '@speclynx/apidom-ns-json-schema-draft-4';
import { SchemaOrReferenceVisitor as SchemaOrReferenceVisitor_3 } from '@speclynx/apidom-ns-json-schema-draft-7';
import { SchemaOrReferenceVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { PatternPropertiesVisitorOptions as SchemaPatternPropertiesVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { PropertiesVisitorOptions as SchemaPropertiesVisitorOptions } from '@speclynx/apidom-ns-json-schema-draft-7';
import { StringElement } from '@speclynx/apidom-datamodel';
import { TypeVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';

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

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: Amqp1ChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp1',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Amqp1ChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type Amqp1ChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type Amqp1MessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type Amqp1OperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type Amqp1ServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: AmqpChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AmqpChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type AmqpChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: AmqpMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AmqpMessageBindingVisitorOptions);
}

/**
 * @public
 */
export declare type AmqpMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: AmqpOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'amqp',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AmqpOperationBindingVisitorOptions);
}

/**
 * @public
 */
export declare type AmqpOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type AmqpServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: AnypointmqChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'anypointmq',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AnypointmqChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type AnypointmqChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: AnypointmqMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'anypointmq',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: AnypointmqMessageBindingVisitorOptions);
}

/**
 * @public
 */
export declare type AnypointmqMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type AnypointmqOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type AnypointmqServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
declare const asyncApi2: NamespacePlugin;
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 idField(): IdentifierElement | undefined;
    set idField(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 BaseFixedFieldsVisitor {
    readonly element: AsyncApi2Element;
    protected readonly specPath: SpecPath<['document', 'objects', 'AsyncApi']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: AsyncApi2VisitorOptions);
}

/**
 * @public
 */
export declare type AsyncApi2VisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseSpecificationVisitor {
    element: AsyncApiVersionElement;
    StringElement(path: Path<StringElement>): void;
}

/**
 * @public
 */
export declare type AsyncApiVersionVisitorOptions = BaseSpecificationVisitorOptions;

/**
 * Base class for visitors using Mixin(AlternatingVisitor, FallbackVisitor)
 * @public
 */
export declare const BaseAlternatingVisitor: Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;

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

/**
 * Base class for visitors using Mixin(FixedFieldsVisitor, FallbackVisitor)
 * @public
 */
export declare const BaseFixedFieldsVisitor: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;

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

/**
 * Base class for visitors using Mixin(MapVisitor, FallbackVisitor)
 * @public
 */
export declare const BaseMapVisitor: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;

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

/**
 * Base class for MixedFieldsVisitor using Mixin(FixedFieldsVisitor, PatternedFieldsVisitor)
 * @public
 */
export declare const BaseMixedFieldsVisitor: Class<any[], FixedFieldsVisitor & PatternedFieldsVisitor, typeof FixedFieldsVisitor & typeof PatternedFieldsVisitor>;

/**
 * @public
 */
export declare interface BaseMixedFieldsVisitorOptions extends FixedFieldsVisitorOptions, PatternedFieldsVisitorOptions {
}

/**
 * Base class for visitors using Mixin(PatternedFieldsVisitor, FallbackVisitor)
 * @public
 */
export declare const BasePatternedFieldsVisitor: Class<any[], PatternedFieldsVisitor & FallbackVisitor, typeof PatternedFieldsVisitor & typeof FallbackVisitor>;

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

/**
 * Base class for visitors using Mixin(SpecificationVisitor, FallbackVisitor)
 * @public
 */
export declare const BaseSpecificationVisitor: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;

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

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: ChannelBindingsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ChannelBindings']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ChannelBindingsVisitorOptions);
}

/**
 * @public
 */
export declare type ChannelBindingsVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare class ChannelItem$RefVisitor extends FallbackVisitor {
    readonly element: StringElement;
    StringElement(path: Path<StringElement>): void;
}

/**
 * @public
 */
export declare class ChannelItemBindingsVisitor extends BaseAlternatingVisitor {
    constructor(options: ChannelItemBindingsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ChannelItemBindingsVisitorOptions = BaseAlternatingVisitorOptions;

/**
 * @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 BaseSpecificationVisitor {
    readonly element: ChannelItemsServersElement;
    constructor(options: ChannelItemServersVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type ChannelItemServersVisitorOptions = BaseSpecificationVisitorOptions;

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

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

/**
 * @public
 */
export declare type ChannelItemVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type ChannelsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsChannelBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ChannelBindings']>;
    constructor(options: ComponentsChannelBindingsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsChannelBindingsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsChannelsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ChannelItem']>;
    constructor(options: ComponentsChannelsVisitorOptions);
}

/**
 * @public
 */
export declare type ComponentsChannelsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsCorrelationIDsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'CorrelationID']>;
    constructor(options: ComponentsCorrelationIdsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsCorrelationIdsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    element: ComponentsMessageBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'MessageBindings']>;
    constructor(options: ComponentsMessageBindingsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsMessageBindingsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsMessagesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Message']>;
    constructor(options: ComponentsMessagesVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsMessagesVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsMessageTraitsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'MessageTrait']>;
    constructor(options: ComponentsMessageTraitsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsMessageTraitsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsOperationBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'OperationBindings']>;
    constructor(options: ComponentsOperationBindingsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsOperationBindingsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsOperationTraitsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'OperationTrait']>;
    constructor(options: ComponentsOperationTraitsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsOperationTraitsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsParametersElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Parameter']>;
    constructor(options: ComponentsParametersVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsParametersVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsSchemasElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Schema']>;
    constructor(options: ComponentsSchemasVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsSchemasVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    element: ComponentsSecuritySchemesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'SecurityScheme']>;
    constructor(options: ComponentsSecuritySchemesVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsSecuritySchemesVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    element: ComponentsServerBindingsElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ServerBindings']>;
    constructor(options: ComponentsServerBindingsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsServerBindingsVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsServersElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'Server']>;
    constructor(options: ComponentsServersVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsServersVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: ComponentsServerVariablesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ServerVariable']>;
    constructor(options: ComponentsServerVariablesVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ComponentsServerVariablesVisitorOptions = BaseMapVisitorOptions;

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

/**
 * @public
 */
export declare type ComponentsVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: ContactElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'Contact']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ContactVisitorOptions);
}

/**
 * @public
 */
export declare type ContactVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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);
}

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

/**
 * @public
 */
export declare type CorrelationIDVisitorOptions = BaseFixedFieldsVisitorOptions;

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

/**
 * @public
 */
export declare class DefaultContentTypeVisitor extends BaseSpecificationVisitor {
    element: DefaultContentTypeElement;
    StringElement(path: Path<StringElement>): void;
}

/**
 * @public
 */
export declare type DefaultContentTypeVisitorOptions = BaseSpecificationVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: ExternalDocumentationElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'ExternalDocumentation']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: ExternalDocumentationVisitorOptions);
}

/**
 * @public
 */
export declare type ExternalDocumentationVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare class FallbackVisitor extends Visitor {
    enter(path: Path<Element_2>): void;
}

/**
 * @public
 */
export declare interface FixedField {
    name: string;
    alias?: string;
    $visitor: unknown;
}

/**
 * @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(path: Path<ObjectElement>): void;
}

/**
 * @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 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 BaseFixedFieldsVisitor {
    readonly element: GooglepubsubChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'googlepubsub',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: GooglepubsubChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type GooglepubsubChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 attributesField(): ObjectElement | undefined;
    set attributesField(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 BaseFixedFieldsVisitor {
    readonly element: GooglepubsubMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'googlepubusb',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: GooglepubsubMessageBindingVisitorOptions);
}

/**
 * @public
 */
export declare type GooglepubsubMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type GooglepubsubOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type GooglepubsubServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type HttpChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: HttpMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'http',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: HttpMessageBindingVisitorOptions);
}

/**
 * @public
 */
export declare type HttpMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: HttpOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'http',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: HttpOperationBindingVisitorOptions);
}

/**
 * @public
 */
export declare type HttpOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type HttpServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: IbmmqChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ibmmq',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: IbmmqChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type IbmmqChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: IbmmqMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ibmmq',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: IbmmqMessageBindingVisitorOptions);
}

/**
 * @public
 */
export declare type IbmmqMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type IbmmqOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: IbmmqServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ibmmq',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: IbmmqServerBindingVisitorOptions);
}

/**
 * @public
 */
export declare type IbmmqServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

/**
 * @public
 */
export declare class IdentifierVisitor extends BaseSpecificationVisitor {
    element: IdentifierElement;
    StringElement(path: Path<StringElement>): void;
}

/**
 * @public
 */
export declare type IdentifierVisitorOptions = BaseSpecificationVisitorOptions;

/**
 * @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(path: Path<StringElement>): void;
}

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

/**
 * @public
 */
export declare type InfoVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

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

export { isBooleanJSONSchemaElement }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @public
 */
export declare type JmsChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type JmsMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type JmsOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type JmsServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: KafkaChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type KafkaChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: KafkaMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaMessageBindingVisitorOptions);
}

/**
 * @public
 */
export declare type KafkaMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: KafkaOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaOperationBindingVisitorOptions);
}

/**
 * @public
 */
export declare type KafkaOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: KafkaServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'kafka',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: KafkaServerBindingVisitorOptions);
}

/**
 * @public
 */
export declare type KafkaServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: LicenseElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'License']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: LicenseVisitorOptions);
}

/**
 * @public
 */
export declare type LicenseVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: MercureChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mercure',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MercureChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type MercureChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type MercureMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type MercureOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type MercureServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseAlternatingVisitor {
    constructor(options: MessageBindingsFieldVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type MessageBindingsFieldVisitorOptions = BaseAlternatingVisitorOptions;

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

/**
 * @public
 */
export declare type MessageBindingsVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare class MessageCorrelationIdVisitor extends BaseAlternatingVisitor {
    constructor(options: MessageCorrelationIdVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type MessageCorrelationIdVisitorOptions = BaseAlternatingVisitorOptions;

/**
 * @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_2 | undefined;
    set payload(payload: SchemaElement | ReferenceElement | Element_2 | 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_2 | undefined;
    set payload(payload: Element_2 | 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 BaseSpecificationVisitor {
    readonly element: MessageExamplesElement;
    constructor(options: MessageExamplesVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type MessageExamplesVisitorOptions = BaseSpecificationVisitorOptions;

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

/**
 * @public
 */
export declare type MessageExampleVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare class MessageHeadersVisitor extends BaseAlternatingVisitor {
    constructor(options: MessageHeadersVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type MessageHeadersVisitorOptions = BaseAlternatingVisitorOptions;

/**
 * @public
 */
export declare class MessageTraitBindingsVisitor extends BaseAlternatingVisitor {
    constructor(options: MessageTraitBindingsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type MessageTraitBindingsVisitorOptions = BaseAlternatingVisitorOptions;

/**
 * @public
 */
export declare class MessageTraitCorrelationIdVisitor extends BaseAlternatingVisitor {
    constructor(options: MessageTraitCorrelationIdVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type MessageTraitCorrelationIdVisitorOptions = BaseAlternatingVisitorOptions;

/**
 * @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 BaseSpecificationVisitor {
    readonly element: MessageTraitExamplesElement;
    constructor(options: MessageTraitExamplesVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type MessageTraitExamplesVisitorOptions = BaseSpecificationVisitorOptions;

/**
 * @public
 */
export declare class MessageTraitHeadersVisitor extends BaseAlternatingVisitor {
    constructor(options: MessageTraitHeadersVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type MessageTraitHeadersVisitorOptions = BaseAlternatingVisitorOptions;

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

/**
 * @public
 */
export declare class MessageTraitsVisitor extends BaseSpecificationVisitor {
    readonly element: MessageTraitsElement;
    constructor(options: MessageTraitsVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type MessageTraitsVisitorOptions = BaseSpecificationVisitorOptions;

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

/**
 * @public
 */
export declare type MessageTraitVisitorOptions = BaseFixedFieldsVisitorOptions;

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

/**
 * 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 type MessageVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare class MixedFieldsVisitor extends BaseMixedFieldsVisitor {
    protected specPathFixedFields: SpecPath;
    protected specPathPatternedFields: SpecPath;
    constructor({ specPathFixedFields, specPathPatternedFields, ...rest }: MixedFieldsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare interface MixedFieldsVisitorOptions extends BaseMixedFieldsVisitorOptions {
    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 BaseFixedFieldsVisitor {
    readonly element: Mqtt5ChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt5',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: Mqtt5ChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type Mqtt5ChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type Mqtt5MessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type Mqtt5OperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type Mqtt5ServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type MqttChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: MqttMessageBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt',
    'MessageBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MqttMessageBindingVisitorOptions);
}

/**
 * @public
 */
export declare type MqttMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: MqttOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MqttOperationBindingVisitorOptions);
}

/**
 * @public
 */
export declare type MqttOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: MqttServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'mqtt',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: MqttServerBindingVisitorOptions);
}

/**
 * @public
 */
export declare type MqttServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type NatsChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type NatsMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: NatsOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'nats',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: NatsOperationBindingVisitorOptions);
}

/**
 * @public
 */
export declare type NatsOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type NatsServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseMapVisitor {
    readonly element: OAuthFlowScopesElement;
    protected readonly specPath: SpecPath<['value']>;
    constructor(options: OAuthFlowScopesVisitorOptions);
}

/**
 * @public
 */
export declare type OAuthFlowScopesVisitorOptions = BaseMapVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: OAuthFlowsElement;
    protected readonly specPath: SpecPath<['document', 'objects', 'OAuthFlows']>;
    protected readonly canSupportSpecificationExtensions: true;
    constructor(options: OAuthFlowsVisitorOptions);
}

/**
 * @public
 */
export declare type OAuthFlowsVisitorOptions = BaseFixedFieldsVisitorOptions;

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

/**
 * @public
 */
export declare type OAuthFlowVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseAlternatingVisitor {
    constructor(options: OperationBindingsFieldVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type OperationBindingsFieldVisitorOptions = BaseAlternatingVisitorOptions;

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

/**
 * @public
 */
export declare type OperationBindingsVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseSpecificationVisitor {
    element: OperationMessageMapElement;
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type OperationMessageVisitorOptions = BaseSpecificationVisitorOptions;

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

/**
 * @public
 */
export declare class OperationSecurityVisitor extends BaseSpecificationVisitor {
    readonly element: OperationSecurityElement;
    constructor(options: OperationSecurityVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type OperationSecurityVisitorOptions = BaseSpecificationVisitorOptions;

/**
 * @public
 */
export declare class OperationTraitBindingsVisitor extends BaseAlternatingVisitor {
    constructor(options: OperationTraitBindingsVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type OperationTraitBindingsVisitorOptions = BaseAlternatingVisitorOptions;

/**
 * @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 BaseSpecificationVisitor {
    readonly element: OperationTraitSecurityElement;
    constructor(options: OperationTraitSecurityVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type OperationTraitSecurityVisitorOptions = BaseSpecificationVisitorOptions;

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

/**
 * @public
 */
export declare class OperationTraitsVisitor extends BaseSpecificationVisitor {
    readonly element: OperationTraitsElement;
    constructor(options: OperationTraitsVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type OperationTraitsVisitorOptions = BaseSpecificationVisitorOptions;

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

/**
 * @public
 */
export declare type OperationTraitVisitorOptions = BaseFixedFieldsVisitorOptions;

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

/**
 * @public
 */
export declare type OperationVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseAlternatingVisitor {
    constructor(options: ParameterSchemaVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ParameterSchemaVisitorOptions = BaseAlternatingVisitorOptions;

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

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

/**
 * @public
 */
export declare type ParametersVisitorOptions = BasePatternedFieldsVisitorOptions;

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

/**
 * @public
 */
export declare type ParameterVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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(path: Path<ObjectElement>): void;
}

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: PulsarChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'pulsar',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: PulsarChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type PulsarChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type PulsarMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type PulsarOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: PulsarServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'pulsar',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: PulsarServerBindingVisitorOptions);
}

/**
 * @public
 */
export declare type PulsarServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type RedisChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type RedisMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type RedisOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type RedisServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare class Reference$RefVisitor extends FallbackVisitor {
    readonly element: StringElement;
    StringElement(path: Path<StringElement>): void;
}

/**
 * @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 {
    hasKey: (value: '$ref') => true;
}

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

/**
 * @public
 */
export declare type ReferenceVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare const refract: <T extends Element_2>(value: unknown, { element, plugins, specificationObj, consume, }?: RefractorOptions) => T;

/**
 * @public
 */
export declare const refractAmqp1ChannelBinding: <T extends Element_2 = Amqp1ChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAmqp1MessageBinding: <T extends Element_2 = Amqp1MessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAmqp1OperationBinding: <T extends Element_2 = Amqp1OperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAmqp1ServerBinding: <T extends Element_2 = Amqp1ServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAmqpChannelBinding: <T extends Element_2 = AmqpChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAmqpMessageBinding: <T extends Element_2 = AmqpMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAmqpOperationBinding: <T extends Element_2 = AmqpOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAmqpServerBinding: <T extends Element_2 = AmqpServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAnypointmqChannelBinding: <T extends Element_2 = AnypointmqChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAnypointmqMessageBinding: <T extends Element_2 = AnypointmqMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAnypointmqOperationBinding: <T extends Element_2 = AnypointmqOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAnypointmqServerBinding: <T extends Element_2 = AnypointmqServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAsyncApi2: <T extends Element_2 = AsyncApi2Element>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractAsyncApiVersion: <T extends Element_2 = AsyncApiVersionElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractChannelBindings: <T extends Element_2 = ChannelBindingsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractChannelItem: <T extends Element_2 = ChannelItemElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractChannels: <T extends Element_2 = ChannelsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractComponents: <T extends Element_2 = ComponentsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractContact: <T extends Element_2 = ContactElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractCorrelationID: <T extends Element_2 = CorrelationIDElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractDefaultContentType: <T extends Element_2 = DefaultContentTypeElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractExternalDocumentation: <T extends Element_2 = ExternalDocumentationElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractGooglepubsubChannelBinding: <T extends Element_2 = GooglepubsubChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractGooglepubsubMessageBinding: <T extends Element_2 = GooglepubsubMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractGooglepubsubOperationBinding: <T extends Element_2 = GooglepubsubOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractGooglepubsubServerBinding: <T extends Element_2 = GooglepubsubServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractHttpChannelBinding: <T extends Element_2 = HttpChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractHttpMessageBinding: <T extends Element_2 = HttpMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractHttpOperationBinding: <T extends Element_2 = HttpOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractHttpServerBinding: <T extends Element_2 = HttpServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractIbmmqChannelBinding: <T extends Element_2 = IbmmqChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractIbmmqMessageBinding: <T extends Element_2 = IbmmqMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractIbmmqOperationBinding: <T extends Element_2 = IbmmqOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractIbmmqServerBinding: <T extends Element_2 = IbmmqServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractIdentifier: <T extends Element_2 = IdentifierElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractInfo: <T extends Element_2 = InfoElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractJmsChannelBinding: <T extends Element_2 = JmsChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractJmsMessageBinding: <T extends Element_2 = JmsMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractJmsOperationBinding: <T extends Element_2 = JmsOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractJmsServerBinding: <T extends Element_2 = JmsServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractKafkaChannelBinding: <T extends Element_2 = KafkaChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractKafkaMessageBinding: <T extends Element_2 = KafkaMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractKafkaOperationBinding: <T extends Element_2 = KafkaOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractKafkaServerBinding: <T extends Element_2 = KafkaServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractLicense: <T extends Element_2 = LicenseElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMercureChannelBinding: <T extends Element_2 = MercureChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMercureMessageBinding: <T extends Element_2 = MercureMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMercureOperationBinding: <T extends Element_2 = MercureOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMercureServerBinding: <T extends Element_2 = MercureServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMessage: <T extends Element_2 = MessageElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMessageBindings: <T extends Element_2 = MessageBindingsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMessageExample: <T extends Element_2 = MessageExampleElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMessageTrait: <T extends Element_2 = MessageTraitElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqtt5ChannelBinding: <T extends Element_2 = Mqtt5ChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqtt5MessageBinding: <T extends Element_2 = Mqtt5MessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqtt5OperationBinding: <T extends Element_2 = Mqtt5OperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqtt5ServerBinding: <T extends Element_2 = Mqtt5ServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqttChannelBinding: <T extends Element_2 = MqttChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqttMessageBinding: <T extends Element_2 = MqttMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqttOperationBinding: <T extends Element_2 = MqttOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractMqttServerBinding: <T extends Element_2 = MqttServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractNatsChannelBinding: <T extends Element_2 = NatsChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractNatsMessageBinding: <T extends Element_2 = NatsMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractNatsOperationBinding: <T extends Element_2 = NatsOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractNatsServerBinding: <T extends Element_2 = NatsServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractOAuthFlow: <T extends Element_2 = OAuthFlowElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractOAuthFlows: <T extends Element_2 = OAuthFlowsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractOperation: <T extends Element_2 = OperationElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractOperationBindings: <T extends Element_2 = OperationBindingsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractOperationTrait: <T extends Element_2 = OperationTraitElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare interface RefractorOptions {
    readonly element?: string;
    readonly plugins?: RefractorPlugin[];
    readonly specificationObj?: typeof specificationObj;
    readonly consume?: boolean;
}

/**
 * @public
 */
export declare type RefractorPlugin = (toolbox: Toolbox) => {
    visitor?: object;
    pre?: () => void;
    post?: () => void;
};

/**
 * @public
 */
export declare const refractorPluginReplaceEmptyElement: () => () => {
    visitor: {
        StringElement(path: Path<StringElement>): void;
    };
};

/**
 * @public
 */
export declare const refractParameter: <T extends Element_2 = ParameterElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractParameters: <T extends Element_2 = ParametersElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractPulsarChannelBinding: <T extends Element_2 = PulsarChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractPulsarMessageBinding: <T extends Element_2 = PulsarMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractPulsarOperationBinding: <T extends Element_2 = PulsarOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractPulsarServerBinding: <T extends Element_2 = PulsarServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractRedisChannelBinding: <T extends Element_2 = RedisChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractRedisMessageBinding: <T extends Element_2 = RedisMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractRedisOperationBinding: <T extends Element_2 = RedisOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractRedisServerBinding: <T extends Element_2 = RedisServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractReference: <T extends Element_2 = ReferenceElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSchema: <T extends Element_2 = SchemaElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSecurityRequirement: <T extends Element_2 = SecurityRequirementElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSecurityScheme: <T extends Element_2 = SecuritySchemeElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractServer: <T extends Element_2 = ServerElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractServerBindings: <T extends Element_2 = ServerBindingsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractServers: <T extends Element_2 = ServersElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractServerVariable: <T extends Element_2 = ServerVariableElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSnsChannelBinding: <T extends Element_2 = SnsChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSnsMessageBinding: <T extends Element_2 = SnsMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSnsOperationBinding: <T extends Element_2 = SnsOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSnsServerBinding: <T extends Element_2 = SnsServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSolaceChannelBinding: <T extends Element_2 = SolaceChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSolaceMessageBinding: <T extends Element_2 = SolaceMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSolaceOperationBinding: <T extends Element_2 = SolaceOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSolaceServerBinding: <T extends Element_2 = SolaceServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSqsChannelBinding: <T extends Element_2 = SqsChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSqsMessageBinding: <T extends Element_2 = SqsMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSqsOperationBinding: <T extends Element_2 = SqsOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractSqsServerBinding: <T extends Element_2 = SqsServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractStompChannelBinding: <T extends Element_2 = StompChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractStompMessageBinding: <T extends Element_2 = StompMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractStompOperationBinding: <T extends Element_2 = StompOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractStompServerBinding: <T extends Element_2 = StompServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractTag: <T extends Element_2 = TagElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractTags: <T extends Element_2 = TagsElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractWebSocketChannelBinding: <T extends Element_2 = WebSocketChannelBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractWebSocketMessageBinding: <T extends Element_2 = WebSocketMessageBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractWebSocketOperationBinding: <T extends Element_2 = WebSocketOperationBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare const refractWebSocketServerBinding: <T extends Element_2 = WebSocketServerBindingElement>(value: unknown, options?: Omit<RefractorOptions, "element">) => T;

/**
 * @public
 */
export declare class SchemaAllOfVisitor extends JSONSchemaAllOfVisitor {
    ArrayElement(path: Path<ArrayElement>): void;
}

export { SchemaAllOfVisitorOptions }

/**
 * @public
 */
export declare class SchemaAnyOfVisitor extends JSONSchemaAnyOfVisitor {
    ArrayElement(path: Path<ArrayElement>): void;
}

export { SchemaAnyOfVisitorOptions }

/**
 * @public
 */
export declare class SchemaDefinitionsVisitor extends JSONSchemaDefinitionsVisitor {
    ObjectElement(path: Path<ObjectElement>): void;
}

export { SchemaDefinitionsVisitorOptions }

/**
 * @public
 */
export declare class SchemaDependenciesVisitor extends JSONSchemaDependenciesVisitor {
    ObjectElement(path: Path<ObjectElement>): void;
}

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 itemsField(): this | BooleanElement | ReferenceElement | ArrayElement | undefined | any;
    set itemsField(items: this | BooleanElement | ReferenceElement | ArrayElement | undefined | any);
    get additionalItems(): this | BooleanElement | ReferenceElement | undefined;
    set additionalItems(additionalItems: this | BooleanElement | ReferenceElement | undefined);
    get contains(): this | BooleanElement | ReferenceElement | undefined;
    set contains(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(path: Path<ObjectElement>): void;
    ArrayElement(path: Path<ArrayElement>): void;
}

export { SchemaItemsVisitorOptions }

/**
 * @public
 */
export declare class SchemaOneOfVisitor extends JSONSchemaOneOfVisitor {
    ArrayElement(path: Path<ArrayElement>): void;
}

export { SchemaOneOfVisitorOptions }

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

export { SchemaOrReferenceVisitorOptions }

/**
 * @public
 */
export declare class SchemaPatternPropertiesVisitor extends JSONSchemaPatternPropertiesVisitor {
    ObjectElement(path: Path<ObjectElement>): void;
}

export { SchemaPatternPropertiesVisitorOptions }

/**
 * @public
 */
export declare class SchemaPropertiesVisitor extends JSONSchemaPropertiesVisitor {
    ObjectElement(path: Path<ObjectElement>): void;
}

export { SchemaPropertiesVisitorOptions }

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

/**
 * @public
 */
export declare type SchemaVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SecurityRequirementVisitorOptions = BaseMapVisitorOptions;

/**
 * @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);
}

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

/**
 * @public
 */
export declare type SecuritySchemeVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseAlternatingVisitor {
    constructor(options: ServerBindingsFieldVisitorOptions);
    ObjectElement(path: Path<ObjectElement>): void;
}

/**
 * @public
 */
export declare type ServerBindingsFieldVisitorOptions = BaseAlternatingVisitorOptions;

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

/**
 * @public
 */
export declare type ServerBindingsVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseSpecificationVisitor {
    readonly element: ServerSecurityElement;
    constructor(options: ServerSecurityVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type ServerSecurityVisitorOptions = BaseSpecificationVisitorOptions;

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

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

/**
 * @public
 */
export declare type ServersVisitorOptions = BasePatternedFieldsVisitorOptions;

/**
 * @public
 */
export declare class ServerUrlVisitor extends FallbackVisitor {
    readonly element: StringElement;
    StringElement(path: Path<StringElement>): void;
}

/**
 * @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 BaseMapVisitor {
    readonly element: ServerVariablesElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'Reference'
    ] | ['document', 'objects', 'ServerVariable']>;
    constructor(options: ServerVariablesVisitorOptions);
}

/**
 * @public
 */
export declare type ServerVariablesVisitorOptions = BaseMapVisitorOptions;

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

/**
 * @public
 */
export declare type ServerVariableVisitorOptions = BaseFixedFieldsVisitorOptions;

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

/**
 * @public
 */
export declare type ServerVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SnsChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SnsMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SnsOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SnsServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SolaceChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SolaceMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: SolaceOperationBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'solace',
    'OperationBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SolaceOperationBindingVisitorOptions);
}

/**
 * @public
 */
export declare type SolaceOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseFixedFieldsVisitor {
    readonly element: SolaceServerBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'solace',
    'ServerBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SolaceServerBindingVisitorOptions);
}

/**
 * @public
 */
export declare type SolaceServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare class SpecificationExtensionVisitor extends SpecificationVisitor {
    element: MemberElement;
    MemberElement(path: Path<MemberElement>): void;
}

/**
 * @public
 */
export declare const specificationObj: {
    visitors: {
        value: typeof FallbackVisitor;
        document: {
            objects: {
                /**
                 * `AsyncApi >= 2.0.0 <=2.6.0` specification elements.
                 */
                AsyncApi: {
                    element: string;
                    $visitor: typeof AsyncApi2Visitor;
                    fixedFields: {
                        asyncapi: {
                            $ref: string;
                        };
                        id: {
                            $visitor: typeof IdentifierVisitor;
                            alias: string;
                        };
                        info: {
                            $ref: string;
                        };
                        servers: {
                            $ref: string;
                        };
                        defaultContentType: {
                            $ref: string;
                        };
                        channels: {
                            $ref: string;
                        };
                        components: {
                            $ref: string;
                        };
                        tags: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                    };
                };
                AsyncApiVersion: {
                    element: string;
                    $visitor: typeof AsyncApiVersionVisitor;
                };
                Identifier: {
                    element: string;
                    $visitor: typeof IdentifierVisitor;
                };
                Info: {
                    element: string;
                    $visitor: typeof InfoVisitor;
                    fixedFields: {
                        title: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        termsOfService: {
                            $ref: string;
                        };
                        version: typeof InfoVersionVisitor;
                        contact: {
                            $ref: string;
                        };
                        license: {
                            $ref: string;
                        };
                    };
                };
                Contact: {
                    element: string;
                    $visitor: typeof ContactVisitor;
                    fixedFields: {
                        name: {
                            $ref: string;
                        };
                        url: {
                            $ref: string;
                        };
                        email: {
                            $ref: string;
                        };
                    };
                };
                License: {
                    element: string;
                    $visitor: typeof LicenseVisitor;
                    fixedFields: {
                        name: {
                            $ref: string;
                        };
                        url: {
                            $ref: string;
                        };
                    };
                };
                Servers: {
                    element: string;
                    $visitor: typeof ServersVisitor;
                };
                Server: {
                    element: string;
                    $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: {
                    element: string;
                    $visitor: typeof ServerVariableVisitor;
                    fixedFields: {
                        enum: {
                            $ref: string;
                        };
                        default: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        examples: {
                            $ref: string;
                        };
                    };
                };
                DefaultContentType: {
                    element: string;
                    $visitor: typeof DefaultContentTypeVisitor;
                };
                Channels: {
                    element: string;
                    $visitor: typeof ChannelsVisitor;
                };
                ChannelItem: {
                    element: string;
                    $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: {
                    element: string;
                    $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: {
                    element: string;
                    $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: {
                    element: string;
                    $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: {
                    element: string;
                    $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: {
                    element: string;
                    $visitor: typeof MessageExampleVisitor;
                    fixedFields: {
                        headers: {
                            $ref: string;
                        };
                        payload: {
                            $ref: string;
                        };
                        name: {
                            $ref: string;
                        };
                        summary: {
                            $ref: string;
                        };
                    };
                };
                Tags: {
                    element: string;
                    $visitor: typeof TagsVisitor;
                };
                Tag: {
                    element: string;
                    $visitor: typeof TagVisitor;
                    fixedFields: {
                        name: {
                            $ref: string;
                        };
                        description: {
                            $ref: string;
                        };
                        externalDocs: {
                            $ref: string;
                        };
                    };
                };
                ExternalDocumentation: {
                    element: string;
                    $visitor: typeof ExternalDocumentationVisitor;
                    fixedFields: {
                        description: {
                            $ref: string;
                        };
                        url: {
                            $ref: string;
                        };
                    };
                };
                Components: {
                    element: string;
                    $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: {
                    element: string;
                    $visitor: typeof ReferenceVisitor;
                    fixedFields: {
                        $ref: typeof Reference$RefVisitor;
                    };
                };
                Reference: {
                    element: string;
                    $visitor: typeof ReferenceVisitor;
                    fixedFields: {
                        $ref: typeof Reference$RefVisitor;
                    };
                };
                JSONSchema: {
                    element: string;
                    $visitor: typeof SchemaVisitor;
                    fixedFields: {
                        allOf: typeof SchemaAllOfVisitor;
                        anyOf: typeof SchemaAnyOfVisitor;
                        oneOf: typeof SchemaOneOfVisitor;
                        items: {
                            $visitor: typeof SchemaItemsVisitor;
                            alias: string;
                        };
                        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 | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        required: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        type: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        default: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        id: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        media: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        title: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        pattern: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        description: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        format: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        links: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        $schema: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        multipleOf: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        exclusiveMaximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        exclusiveMinimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maxLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        additionalItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maxItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        uniqueItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maxProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        additionalProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        enum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        not: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        readOnly: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                    };
                };
                Schema: {
                    element: string;
                    $visitor: typeof SchemaVisitor;
                    fixedFields: {
                        allOf: typeof SchemaAllOfVisitor;
                        anyOf: typeof SchemaAnyOfVisitor;
                        oneOf: typeof SchemaOneOfVisitor;
                        items: {
                            $visitor: typeof SchemaItemsVisitor;
                            alias: string;
                        };
                        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 | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        required: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        type: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        default: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        id: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        media: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        title: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        pattern: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        description: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        format: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        links: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        $schema: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        multipleOf: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        exclusiveMaximum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        exclusiveMinimum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maxLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minLength: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        additionalItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maxItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        uniqueItems: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        maxProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        minProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        additionalProperties: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        enum: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        not: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                        readOnly: DefinitionsVisitor_2 | DependenciesVisitor_2 | EnumVisitor | PatternPropertiesVisitor_2 | PropertiesVisitor_2 | SchemaOrReferenceVisitor_2 | {
                            $ref: string;
                        } | {
                            $visitor: ItemsVisitor;
                            alias: string;
                        } | TypeVisitor | {
                            $visitor: LinksVisitor;
                            alias: string;
                        } | typeof SchemaOrReferenceVisitor;
                    };
                };
                LinkDescription: {
                    element: string;
                    $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: {
                    element: string;
                    $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: {
                    element: string;
                    $visitor: typeof SecurityRequirementVisitor;
                };
                OAuthFlows: {
                    element: string;
                    $visitor: typeof OAuthFlowsVisitor;
                    fixedFields: {
                        implicit: {
                            $ref: string;
                        };
                        password: {
                            $ref: string;
                        };
                        clientCredentials: {
                            $ref: string;
                        };
                        authorizationCode: {
                            $ref: string;
                        };
                    };
                };
                OAuthFlow: {
                    element: string;
                    $visitor: typeof OAuthFlowVisitor;
                    fixedFields: {
                        authorizationUrl: {
                            $ref: string;
                        };
                        tokenUrl: {
                            $ref: string;
                        };
                        refreshUrl: {
                            $ref: string;
                        };
                        scopes: typeof OAuthFlowScopesVisitor;
                    };
                };
                ServerBindings: {
                    element: string;
                    $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: {
                    element: string;
                    $visitor: typeof ParametersVisitor;
                };
                Parameter: {
                    element: string;
                    $visitor: typeof ParameterVisitor;
                    fixedFields: {
                        description: {
                            $ref: string;
                        };
                        schema: typeof ParameterSchemaVisitor;
                        location: {
                            $ref: string;
                        };
                    };
                };
                ChannelBindings: {
                    element: string;
                    $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: {
                    element: string;
                    $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: {
                    element: string;
                    $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: {
                    element: string;
                    $visitor: typeof CorrelationIDVisitor;
                    fixedFields: {
                        description: {
                            $ref: string;
                        };
                        location: {
                            $ref: string;
                        };
                    };
                };
                bindings: {
                    http: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof HttpServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof HttpChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof HttpOperationBindingVisitor;
                            fixedFields: {
                                type: {
                                    $ref: string;
                                };
                                method: {
                                    $ref: string;
                                };
                                query: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof HttpMessageBindingVisitor;
                            fixedFields: {
                                headers: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    ws: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof WebSocketServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof WebSocketChannelBindingVisitor;
                            fixedFields: {
                                method: {
                                    $ref: string;
                                };
                                query: typeof SchemaOrReferenceVisitor;
                                headers: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof WebSocketOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof WebSocketMessageBindingVisitor;
                        };
                    };
                    kafka: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof KafkaServerBindingVisitor;
                            fixedFields: {
                                schemaRegistryUrl: {
                                    $ref: string;
                                };
                                schemaRegistryVendor: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof KafkaChannelBindingVisitor;
                            fixedFields: {
                                topic: {
                                    $ref: string;
                                };
                                partitions: {
                                    $ref: string;
                                };
                                replicas: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof KafkaOperationBindingVisitor;
                            fixedFields: {
                                groupId: typeof SchemaOrReferenceVisitor;
                                clientId: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof KafkaMessageBindingVisitor;
                            fixedFields: {
                                key: typeof SchemaOrReferenceVisitor;
                                schemaIdLocation: {
                                    $ref: string;
                                };
                                schemaIdPayloadEncoding: {
                                    $ref: string;
                                };
                                schemaLookupStrategy: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    anypointmq: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof AnypointmqServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof AnypointmqChannelBindingVisitor;
                            fixedFields: {
                                destination: {
                                    $ref: string;
                                };
                                destinationType: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof AnypointmqOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof AnypointmqMessageBindingVisitor;
                            fixedFields: {
                                headers: typeof SchemaOrReferenceVisitor;
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    amqp: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof AmqpServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof AmqpChannelBindingVisitor;
                            fixedFields: {
                                is: {
                                    $ref: string;
                                };
                                exchange: {
                                    $ref: string;
                                };
                                queue: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            element: string;
                            $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: {
                            element: string;
                            $visitor: typeof AmqpMessageBindingVisitor;
                            fixedFields: {
                                contentEncoding: {
                                    $ref: string;
                                };
                                messageType: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    amqp1: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof Amqp1ServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof Amqp1ChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof Amqp1OperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof Amqp1MessageBindingVisitor;
                        };
                    };
                    mqtt: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof MqttServerBindingVisitor;
                            fixedFields: {
                                clientId: {
                                    $ref: string;
                                };
                                cleanSession: {
                                    $ref: string;
                                };
                                lastWill: {
                                    $ref: string;
                                };
                                keepAlive: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof MqttChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof MqttOperationBindingVisitor;
                            fixedFields: {
                                qos: {
                                    $ref: string;
                                };
                                retain: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof MqttMessageBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    mqtt5: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof Mqtt5ServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof Mqtt5ChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof Mqtt5OperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof Mqtt5MessageBindingVisitor;
                        };
                    };
                    nats: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof NatsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof NatsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof NatsOperationBindingVisitor;
                            fixedFields: {
                                queue: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof NatsMessageBindingVisitor;
                        };
                    };
                    pulsar: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof PulsarServerBindingVisitor;
                            fixedFields: {
                                tenant: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            element: string;
                            $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: {
                            element: string;
                            $visitor: typeof PulsarOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof PulsarMessageBindingVisitor;
                        };
                    };
                    jms: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof JmsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof JmsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof JmsOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof JmsMessageBindingVisitor;
                        };
                    };
                    sns: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof SnsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof SnsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof SnsOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof SnsMessageBindingVisitor;
                        };
                    };
                    solace: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof SolaceServerBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                msgVpn: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof SolaceChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof SolaceOperationBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                destinations: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof SolaceMessageBindingVisitor;
                        };
                    };
                    sqs: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof SqsServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof SqsChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof SqsOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof SqsMessageBindingVisitor;
                        };
                    };
                    stomp: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof StompServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof StompChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof StompOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof StompMessageBindingVisitor;
                        };
                    };
                    redis: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof RedisServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof RedisChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof RedisOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof RedisMessageBindingVisitor;
                        };
                    };
                    mercure: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof MercureServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof MercureChannelBindingVisitor;
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof MercureOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof MercureMessageBindingVisitor;
                        };
                    };
                    googlepubsub: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof GooglepubsubServerBindingVisitor;
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof GooglepubsubChannelBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                labels: {
                                    $ref: string;
                                };
                                messageRetentionDuration: {
                                    $ref: string;
                                };
                                messageStoragePolicy: {
                                    $ref: string;
                                };
                                schemaSettings: {
                                    $ref: string;
                                };
                                topic: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            element: string;
                            $visitor: typeof GooglepubsubOperationBindingVisitor;
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof GooglepubsubMessageBindingVisitor;
                            fixedFields: {
                                bindingVersion: {
                                    $ref: string;
                                };
                                attributes: {
                                    $ref: string;
                                    alias: string;
                                };
                                orderingKey: {
                                    $ref: string;
                                };
                                schema: {
                                    $ref: string;
                                };
                            };
                        };
                    };
                    ibmmq: {
                        ServerBinding: {
                            element: string;
                            $visitor: typeof IbmmqServerBindingVisitor;
                            fixedFields: {
                                groupId: {
                                    $ref: string;
                                };
                                ccdtQueueManagerName: {
                                    $ref: string;
                                };
                                cipherSpec: {
                                    $ref: string;
                                };
                                multiEndpointServer: {
                                    $ref: string;
                                };
                                heartBeatInterval: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        ChannelBinding: {
                            element: string;
                            $visitor: typeof IbmmqChannelBindingVisitor;
                            fixedFields: {
                                destinationType: {
                                    $ref: string;
                                };
                                queue: {
                                    $ref: string;
                                };
                                topic: {
                                    $ref: string;
                                };
                                maxMsgLength: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        MessageBinding: {
                            element: string;
                            $visitor: typeof IbmmqMessageBindingVisitor;
                            fixedFields: {
                                type: {
                                    $ref: string;
                                };
                                headers: {
                                    $ref: string;
                                };
                                description: {
                                    $ref: string;
                                };
                                expiry: {
                                    $ref: string;
                                };
                                bindingVersion: {
                                    $ref: string;
                                };
                            };
                        };
                        OperationBinding: {
                            element: string;
                            $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(): Record<string, unknown>;
    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 BaseFixedFieldsVisitor {
    readonly element: SqsChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'sqs',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: SqsChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type SqsChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SqsMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SqsOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type SqsServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type StompChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type StompMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type StompOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type StompServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @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 BaseSpecificationVisitor {
    readonly element: TagsElement;
    constructor(options: TagsVisitorOptions);
    ArrayElement(path: Path<ArrayElement>): void;
}

/**
 * @public
 */
export declare type TagsVisitorOptions = BaseSpecificationVisitorOptions;

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

/**
 * @public
 */
export declare type TagVisitorOptions = BaseFixedFieldsVisitorOptions;

/**
 * @public
 */
export declare interface Toolbox {
    predicates: Record<string, (...args: any[]) => boolean>;
    namespace: Namespace;
}

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

/**
 * @public
 */
declare interface VisitorOptions {
    readonly consume?: boolean;
}
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 BaseFixedFieldsVisitor {
    readonly element: WebSocketChannelBindingElement;
    protected readonly specPath: SpecPath<[
    'document',
    'objects',
    'bindings',
    'ws',
    'ChannelBinding'
    ]>;
    protected readonly canSupportSpecificationExtensions: false;
    constructor(options: WebSocketChannelBindingVisitorOptions);
}

/**
 * @public
 */
export declare type WebSocketChannelBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type WebSocketMessageBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type WebSocketOperationBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

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

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

/**
 * @public
 */
export declare type WebSocketServerBindingVisitorOptions = BaseFixedFieldsVisitorOptions;

export { }