@swagger-api/apidom-ns-openapi-2 0.93.0 → 0.94.0

package/types/dist.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="@swagger-api/apidom-core/types/minim" />
 import * as _swagger_api_apidom_core from '@swagger-api/apidom-core';
-import { MediaTypes, NamespacePluginOptions, StringElement, Element, Meta, Attributes, ObjectElement, ArrayElement, BooleanElement, NumberElement, MemberElement } from '@swagger-api/apidom-core';
+import { MediaTypes, NamespacePluginOptions, StringElement, Element, Meta, Attributes, ObjectElement, ArrayElement, MemberElement, BooleanElement, NumberElement } from '@swagger-api/apidom-core';
 export { isArrayElement, isBooleanElement, isElement, isLinkElement as isLinkPrimitiveElement, isMemberElement, isNullElement, isNumberElement, isObjectElement, isRefElement, isStringElement } from '@swagger-api/apidom-core';
 import { JSONSchemaElement, JSONReferenceElement, MediaElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
 export { JSONReferenceElement, isJSONReferenceElement, isJSONReferenceLikeElement } from '@swagger-api/apidom-ns-json-schema-draft-4';
 import * as minim from 'minim';
 import * as stampit from 'stampit';
-import stampit__default from 'stampit';
+import * as ts_mixer_dist_types_types from 'ts-mixer/dist/types/types';
 
 type Format = 'generic' | 'json' | 'yaml';
 declare class OpenAPIMediaTypes extends MediaTypes<string> {
@@ -32,422 +32,17 @@ declare const refract: <T extends Element>(value: unknown, { specPath, plugins }
 }) => T;
 declare const createRefractor: (specPath: string[]) => (value: unknown, options?: {}) => Element;
 
-declare const specification: {
-    visitors: {
-        value: stampit.default.Stamp<any>;
-        document: {
-            objects: {
-                JSONReference: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        $ref: stampit.default.Stamp<any>;
-                    };
-                };
-                JSONSchema: {
-                    $ref: string;
-                };
-                Swagger: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        swagger: stampit.default.Stamp<any>;
-                        info: {
-                            $ref: string;
-                        };
-                        host: stampit.default.Stamp<any>;
-                        basePath: stampit.default.Stamp<any>;
-                        schemes: stampit.default.Stamp<any>;
-                        consumes: stampit.default.Stamp<any>;
-                        produces: stampit.default.Stamp<any>;
-                        paths: {
-                            $ref: string;
-                        };
-                        definitions: {
-                            $ref: string;
-                        };
-                        parameters: {
-                            $ref: string;
-                        };
-                        responses: {
-                            $ref: string;
-                        };
-                        securityDefinitions: {
-                            $ref: string;
-                        };
-                        security: stampit.default.Stamp<any>;
-                        tags: stampit.default.Stamp<any>;
-                        externalDocs: {
-                            $ref: string;
-                        };
-                    };
-                };
-                Info: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        title: {
-                            $ref: string;
-                        };
-                        description: {
-                            $ref: string;
-                        };
-                        termsOfService: {
-                            $ref: string;
-                        };
-                        contact: {
-                            $ref: string;
-                        };
-                        license: {
-                            $ref: string;
-                        };
-                        version: stampit.default.Stamp<any>;
-                    };
-                };
-                Contact: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        name: {
-                            $ref: string;
-                        };
-                        url: {
-                            $ref: string;
-                        };
-                        email: {
-                            $ref: string;
-                        };
-                    };
-                };
-                License: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        name: {
-                            $ref: string;
-                        };
-                        url: {
-                            $ref: string;
-                        };
-                    };
-                };
-                Paths: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                PathItem: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        $ref: stampit.default.Stamp<any>;
-                        get: {
-                            $ref: string;
-                        };
-                        put: {
-                            $ref: string;
-                        };
-                        post: {
-                            $ref: string;
-                        };
-                        delete: {
-                            $ref: string;
-                        };
-                        options: {
-                            $ref: string;
-                        };
-                        head: {
-                            $ref: string;
-                        };
-                        patch: {
-                            $ref: string;
-                        };
-                        parameters: stampit.default.Stamp<any>;
-                    };
-                };
-                Operation: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        tags: stampit.default.Stamp<any>;
-                        summary: {
-                            $ref: string;
-                        };
-                        description: {
-                            $ref: string;
-                        };
-                        externalDocs: {
-                            $ref: string;
-                        };
-                        operationId: {
-                            $ref: string;
-                        };
-                        consumes: stampit.default.Stamp<any>;
-                        produces: stampit.default.Stamp<any>;
-                        parameters: stampit.default.Stamp<any>;
-                        responses: {
-                            $ref: string;
-                        };
-                        schemes: stampit.default.Stamp<any>;
-                        deprecated: {
-                            $ref: string;
-                        };
-                        security: stampit.default.Stamp<any>;
-                    };
-                };
-                ExternalDocumentation: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        description: {
-                            $ref: string;
-                        };
-                        url: {
-                            $ref: string;
-                        };
-                    };
-                };
-                Parameter: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        name: {
-                            $ref: string;
-                        };
-                        in: {
-                            $ref: string;
-                        };
-                        description: stampit.default.Stamp<any>;
-                        required: stampit.default.Stamp<any>;
-                        schema: stampit.default.Stamp<any>;
-                        type: stampit.default.Stamp<any>;
-                        format: stampit.default.Stamp<any>;
-                        items: {
-                            $ref: string;
-                        };
-                        collectionFormat: {
-                            $ref: string;
-                        };
-                        default: stampit.default.Stamp<any>;
-                        maximum: stampit.default.Stamp<any>;
-                        exclusiveMaximum: stampit.default.Stamp<any>;
-                        minimum: stampit.default.Stamp<any>;
-                        exclusiveMinimum: stampit.default.Stamp<any>;
-                        maxLength: stampit.default.Stamp<any>;
-                        minLength: stampit.default.Stamp<any>;
-                        pattern: stampit.default.Stamp<any>;
-                        maxItems: stampit.default.Stamp<any>;
-                        minItems: stampit.default.Stamp<any>;
-                        uniqueItems: stampit.default.Stamp<any>;
-                        enum: stampit.default.Stamp<any>;
-                        multipleOf: stampit.default.Stamp<any>;
-                    };
-                };
-                Items: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        type: stampit.default.Stamp<any>;
-                        format: stampit.default.Stamp<any>;
-                        items: {
-                            $ref: string;
-                        };
-                        collectionFormat: {
-                            $ref: string;
-                        };
-                        default: stampit.default.Stamp<any>;
-                        maximum: stampit.default.Stamp<any>;
-                        exclusiveMaximum: stampit.default.Stamp<any>;
-                        minimum: stampit.default.Stamp<any>;
-                        exclusiveMinimum: stampit.default.Stamp<any>;
-                        maxLength: stampit.default.Stamp<any>;
-                        minLength: stampit.default.Stamp<any>;
-                        pattern: stampit.default.Stamp<any>;
-                        maxItems: stampit.default.Stamp<any>;
-                        minItems: stampit.default.Stamp<any>;
-                        uniqueItems: stampit.default.Stamp<any>;
-                        enum: stampit.default.Stamp<any>;
-                        multipleOf: stampit.default.Stamp<any>;
-                    };
-                };
-                Responses: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        default: stampit.default.Stamp<any>;
-                    };
-                };
-                Response: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        description: {
-                            $ref: string;
-                        };
-                        schema: stampit.default.Stamp<any>;
-                        headers: {
-                            $ref: string;
-                        };
-                        examples: {
-                            $ref: string;
-                        };
-                    };
-                };
-                Headers: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                Example: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                Header: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        description: stampit.default.Stamp<any>;
-                        type: stampit.default.Stamp<any>;
-                        format: stampit.default.Stamp<any>;
-                        items: {
-                            $ref: string;
-                        };
-                        collectionFormat: {
-                            $ref: string;
-                        };
-                        default: stampit.default.Stamp<any>;
-                        maximum: stampit.default.Stamp<any>;
-                        exclusiveMaximum: stampit.default.Stamp<any>;
-                        minimum: stampit.default.Stamp<any>;
-                        exclusiveMinimum: stampit.default.Stamp<any>;
-                        maxLength: stampit.default.Stamp<any>;
-                        minLength: stampit.default.Stamp<any>;
-                        pattern: stampit.default.Stamp<any>;
-                        maxItems: stampit.default.Stamp<any>;
-                        minItems: stampit.default.Stamp<any>;
-                        uniqueItems: stampit.default.Stamp<any>;
-                        enum: stampit.default.Stamp<any>;
-                        multipleOf: stampit.default.Stamp<any>;
-                    };
-                };
-                Tag: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        name: {
-                            $ref: string;
-                        };
-                        description: {
-                            $ref: string;
-                        };
-                        externalDocs: {
-                            $ref: string;
-                        };
-                    };
-                };
-                Reference: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        $ref: stampit.default.Stamp<any>;
-                    };
-                };
-                Schema: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        format: stampit.default.Stamp<any>;
-                        title: stampit.default.Stamp<any>;
-                        description: stampit.default.Stamp<any>;
-                        default: stampit.default.Stamp<any>;
-                        multipleOf: stampit.default.Stamp<any>;
-                        maximum: stampit.default.Stamp<any>;
-                        exclusiveMaximum: stampit.default.Stamp<any>;
-                        minimum: stampit.default.Stamp<any>;
-                        exclusiveMinimum: stampit.default.Stamp<any>;
-                        maxLength: stampit.default.Stamp<any>;
-                        minLength: stampit.default.Stamp<any>;
-                        pattern: stampit.default.Stamp<any>;
-                        maxItems: stampit.default.Stamp<any>;
-                        minItems: stampit.default.Stamp<any>;
-                        uniqueItems: stampit.default.Stamp<any>;
-                        maxProperties: stampit.default.Stamp<any>;
-                        minProperties: stampit.default.Stamp<any>;
-                        required: stampit.default.Stamp<any>;
-                        enum: stampit.default.Stamp<any>;
-                        type: stampit.default.Stamp<any>;
-                        readOnly: stampit.default.Stamp<any>;
-                        items: stampit.default.Stamp<any>;
-                        allOf: stampit.default.Stamp<any>;
-                        properties: stampit.default.Stamp<any>;
-                        additionalProperties: stampit.default.Stamp<any>;
-                        discriminator: {
-                            $ref: string;
-                        };
-                        xml: {
-                            $ref: string;
-                        };
-                        externalDocs: {
-                            $ref: string;
-                        };
-                        example: {
-                            $ref: string;
-                        };
-                    };
-                };
-                XML: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        name: {
-                            $ref: string;
-                        };
-                        namespace: {
-                            $ref: string;
-                        };
-                        prefix: {
-                            $ref: string;
-                        };
-                        attribute: {
-                            $ref: string;
-                        };
-                        wrapped: {
-                            $ref: string;
-                        };
-                    };
-                };
-                Definitions: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                ParametersDefinitions: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                ResponsesDefinitions: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                SecurityDefinitions: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                SecurityScheme: {
-                    $visitor: stampit.default.Stamp<any>;
-                    fixedFields: {
-                        type: {
-                            $ref: string;
-                        };
-                        description: {
-                            $ref: string;
-                        };
-                        name: {
-                            $ref: string;
-                        };
-                        in: {
-                            $ref: string;
-                        };
-                        flow: {
-                            $ref: string;
-                        };
-                        authorizationUrl: {
-                            $ref: string;
-                        };
-                        token: {
-                            $ref: string;
-                        };
-                        scopes: {
-                            $ref: string;
-                        };
-                    };
-                };
-                Scopes: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-                SecurityRequirement: {
-                    $visitor: stampit.default.Stamp<any>;
-                };
-            };
-            extension: {
-                $visitor: stampit.default.Stamp<any>;
-            };
-        };
-    };
-};
+interface VisitorOptions {
+}
+declare class Visitor {
+    element: Element;
+    constructor(options?: VisitorOptions);
+    copyMetaAndAttributes(from: Element, to: Element): void;
+}
+
+declare class FallbackVisitor extends Visitor {
+    enter(element: Element): {};
+}
 
 declare class SwaggerVersion extends StringElement {
     constructor(content?: string, meta?: Meta, attributes?: Attributes);
@@ -549,6 +144,182 @@ declare class Swagger extends ObjectElement {
     set externalDocs(externalDocs: ExternalDocumentation | undefined);
 }
 
+/**
+ * This is a base Type for every visitor that does
+ * internal look-ups to retrieve other child visitors.
+ */
+interface SpecificationVisitorOptions extends VisitorOptions {
+    readonly specObj: typeof specification;
+}
+declare class SpecificationVisitor extends Visitor {
+    protected readonly specObj: typeof specification;
+    protected readonly passingOptionsNames: string[];
+    constructor({ specObj, ...rest }: SpecificationVisitorOptions);
+    retrievePassingOptions(): string extends keyof this ? Record<keyof this & string, this[keyof this]> : Pick<this, keyof this>;
+    retrieveFixedFields(specPath: string[]): string[];
+    retrieveVisitor(specPath: string[]): unknown;
+    retrieveVisitorInstance(specPath: string[], options?: {}): Visitor;
+    toRefractedElement(specPath: string[], element: any, options?: {}): any;
+}
+
+interface ReferenceLikeElement extends ObjectElement {
+    hasKey: (value: '$ref') => true;
+}
+declare const isSwaggerExtension: (element: MemberElement) => boolean;
+declare const isReferenceLikeElement: (element: unknown) => element is ReferenceLikeElement;
+
+type SpecPath<T = string[]> = (element: unknown) => T;
+interface FixedFieldsVisitorOptions extends SpecificationVisitorOptions {
+    readonly specPath: SpecPath;
+    readonly ignoredFields?: string[];
+    readonly canSupportSpecificationExtensions?: boolean;
+    readonly specificationExtensionPredicate?: typeof isSwaggerExtension;
+}
+declare class FixedFieldsVisitor extends SpecificationVisitor {
+    protected specPath: SpecPath;
+    protected ignoredFields: string[];
+    protected canSupportSpecificationExtensions: boolean;
+    protected specificationExtensionPredicate: (element: MemberElement) => boolean;
+    constructor({ specPath, ignoredFields, canSupportSpecificationExtensions, specificationExtensionPredicate, ...rest }: FixedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare const SwaggerVisitor_base$1: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class SwaggerVisitor$1 extends SwaggerVisitor_base$1 {
+    readonly element: Swagger;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Swagger']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+declare const SwaggerVisitor_base: ts_mixer_dist_types_types.Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+declare class SwaggerVisitor extends SwaggerVisitor_base {
+    element: SwaggerVersion;
+    StringElement(stringElement: StringElement): {};
+}
+
+declare class HostVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+declare class BasePathVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+declare class SwaggerSchemes extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare class SchemesVisitor$1 extends FallbackVisitor {
+    element: SwaggerSchemes;
+    constructor(options: VisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class SwaggerConsumes extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare class ConsumesVisitor$1 extends FallbackVisitor {
+    element: SwaggerConsumes;
+    constructor(options: VisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class SwaggerProduces extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare class ProducesVisitor$1 extends FallbackVisitor {
+    element: SwaggerProduces;
+    constructor(options: VisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class SwaggerSecurity extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare const SecurityVisitor_base$1: ts_mixer_dist_types_types.Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+declare class SecurityVisitor$1 extends SecurityVisitor_base$1 {
+    readonly element: SwaggerSecurity;
+    constructor(options: SpecificationVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class SwaggerTags extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare const TagsVisitor_base: ts_mixer_dist_types_types.Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+declare class TagsVisitor$1 extends TagsVisitor_base {
+    readonly element: SwaggerTags;
+    constructor(options: SpecificationVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare const InfoVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class InfoVisitor extends InfoVisitor_base {
+    readonly element: Info;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Info']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+declare class VersionVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+declare const ContactVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class ContactVisitor extends ContactVisitor_base {
+    readonly element: Contact;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Contact']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+declare const LicenseVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class LicenseVisitor extends LicenseVisitor_base {
+    readonly element: License;
+    protected readonly specPath: SpecPath<['document', 'objects', 'License']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+interface PatternedFieldsVisitorOptions extends SpecificationVisitorOptions {
+    readonly specPath: SpecPath;
+    readonly ignoredFields?: string[];
+    readonly fieldPatternPredicate?: (...args: unknown[]) => boolean;
+    readonly canSupportSpecificationExtensions?: boolean;
+    readonly specificationExtensionPredicate?: typeof isSwaggerExtension;
+}
+declare class PatternedFieldsVisitor extends SpecificationVisitor {
+    protected specPath: SpecPath;
+    protected ignoredFields: string[];
+    protected fieldPatternPredicate: (value: unknown) => boolean;
+    protected canSupportSpecificationExtensions: boolean;
+    protected specificationExtensionPredicate: (element: MemberElement) => boolean;
+    constructor({ specPath, ignoredFields, fieldPatternPredicate, canSupportSpecificationExtensions, specificationExtensionPredicate, ...rest }: PatternedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare const PathsVisitor_base: ts_mixer_dist_types_types.Class<any[], PatternedFieldsVisitor & FallbackVisitor, typeof PatternedFieldsVisitor & typeof FallbackVisitor>;
+declare class PathsVisitor extends PathsVisitor_base {
+    readonly element: Paths;
+    protected readonly specPath: SpecPath<['document', 'objects', 'PathItem']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: PatternedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
 declare class Schema extends JSONSchemaElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
     /**
@@ -674,6 +445,114 @@ declare class PathItem extends ObjectElement {
     set parameters(parameters: ArrayElement | undefined);
 }
 
+declare const PathItemVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class PathItemVisitor extends PathItemVisitor_base {
+    readonly element: PathItem;
+    protected readonly specPath: SpecPath<['document', 'objects', 'PathItem']>;
+    constructor(options: FixedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare class $RefVisitor$1 extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+declare class PathItemParameters extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare const ParametersVisitor_base$1: ts_mixer_dist_types_types.Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+declare class ParametersVisitor$1 extends ParametersVisitor_base$1 {
+    readonly element: PathItemParameters;
+    constructor(options: SpecificationVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare const OperationVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class OperationVisitor extends OperationVisitor_base {
+    readonly element: Operation;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Operation']>;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+declare class OperationTags extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare class TagsVisitor extends FallbackVisitor {
+    element: OperationTags;
+    constructor(options: VisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class OperationConsumes extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare class ConsumesVisitor extends FallbackVisitor {
+    element: OperationConsumes;
+    constructor(options: VisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class OperationProduces extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare class ProducesVisitor extends FallbackVisitor {
+    element: OperationProduces;
+    constructor(options: VisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class OperationParameters extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare const ParametersVisitor_base: ts_mixer_dist_types_types.Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+declare class ParametersVisitor extends ParametersVisitor_base {
+    readonly element: OperationParameters;
+    constructor(options: SpecificationVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class OperationSchemes extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare class SchemesVisitor extends FallbackVisitor {
+    element: OperationSchemes;
+    constructor(options: VisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare class OperationSecurity extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare const SecurityVisitor_base: ts_mixer_dist_types_types.Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+declare class SecurityVisitor extends SecurityVisitor_base {
+    readonly element: OperationSecurity;
+    constructor(options: SpecificationVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare const ExternalDocumentationVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class ExternalDocumentationVisitor extends ExternalDocumentationVisitor_base {
+    readonly element: ExternalDocumentation;
+    protected readonly specPath: SpecPath<['document', 'objects', 'ExternalDocumentation']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
 declare class Parameter extends JSONSchemaElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
     /**
@@ -764,6 +643,14 @@ declare class Parameter extends JSONSchemaElement {
     set schema(schema: Schema | undefined);
 }
 
+declare const ParameterVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class ParameterVisitor extends ParameterVisitor_base {
+    readonly element: Parameter;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Parameter']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
 declare class Items extends JSONSchemaElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
     /**
@@ -838,6 +725,89 @@ declare class Items extends JSONSchemaElement {
     set readOnly(readOnly: BooleanElement | undefined);
 }
 
+declare const ItemsVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class ItemsVisitor extends ItemsVisitor_base {
+    readonly element: Items;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Items']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+interface MixedFieldsVisitorOptions extends PatternedFieldsVisitorOptions {
+    readonly specPathFixedFields: SpecPath;
+    readonly specPathPatternedFields: SpecPath;
+}
+declare const MixedFieldsVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & PatternedFieldsVisitor, typeof FixedFieldsVisitor & typeof PatternedFieldsVisitor>;
+declare class MixedFieldsVisitor extends MixedFieldsVisitor_base {
+    protected readonly specPathFixedFields: SpecPath;
+    protected readonly specPathPatternedFields: SpecPath;
+    constructor({ specPathFixedFields, specPathPatternedFields, ...rest }: MixedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare const ResponsesVisitor_base: ts_mixer_dist_types_types.Class<any[], MixedFieldsVisitor & FallbackVisitor, typeof MixedFieldsVisitor & typeof FallbackVisitor>;
+declare class ResponsesVisitor extends ResponsesVisitor_base {
+    readonly element: Responses;
+    protected readonly specPathFixedFields: SpecPath<['document', 'objects', 'Responses']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    protected readonly specPathPatternedFields: SpecPath<[
+        'document',
+        'objects',
+        'Reference'
+    ] | ['document', 'objects', 'Response']>;
+    constructor(options: MixedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+type Alternator = {
+    predicate: (element: unknown) => boolean;
+    specPath: string[];
+};
+interface AlternatingVisitorOptions extends SpecificationVisitorOptions {
+    readonly alternator?: Alternator[];
+}
+declare class AlternatingVisitor extends SpecificationVisitor {
+    protected alternator: Alternator[];
+    constructor({ alternator, ...rest }: AlternatingVisitorOptions);
+    enter(element: Element): {};
+}
+
+declare const DefaultVisitor_base: ts_mixer_dist_types_types.Class<any[], AlternatingVisitor & FallbackVisitor, typeof AlternatingVisitor & typeof FallbackVisitor>;
+declare class DefaultVisitor extends DefaultVisitor_base {
+    constructor(options: AlternatingVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare const ResponseVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class ResponseVisitor extends ResponseVisitor_base {
+    readonly element: Response;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Response']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+interface MapVisitorOptions extends PatternedFieldsVisitorOptions {
+}
+declare class MapVisitor extends PatternedFieldsVisitor {
+    constructor(options: MapVisitorOptions);
+}
+
+declare const HeadersVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class HeadersVisitor extends HeadersVisitor_base {
+    readonly element: Headers;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Header']>;
+    protected readonly canSupportSpecificationExtensions: false;
+    constructor(options: MapVisitorOptions);
+}
+
+declare const ExampleVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class ExampleVisitor extends ExampleVisitor_base {
+    readonly element: Example;
+    protected readonly specPath: SpecPath<['value']>;
+    protected readonly canSupportSpecificationExtensions: false;
+    constructor(options: MapVisitorOptions);
+}
+
 declare class Header extends JSONSchemaElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
     /**
@@ -910,6 +880,14 @@ declare class Header extends JSONSchemaElement {
     set readOnly(readOnly: BooleanElement | undefined);
 }
 
+declare const HeaderVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class HeaderVisitor extends HeaderVisitor_base {
+    readonly element: Header;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Header']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
 declare class Tag extends ObjectElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
     get name(): StringElement | undefined;
@@ -920,6 +898,36 @@ declare class Tag extends ObjectElement {
     set externalDocs(externalDocs: ExternalDocumentation | undefined);
 }
 
+declare const TagVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class TagVisitor extends TagVisitor_base {
+    readonly element: Tag;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Tag']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+declare const ReferenceVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class ReferenceVisitor extends ReferenceVisitor_base {
+    readonly element: Reference;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Reference']>;
+    protected readonly canSupportSpecificationExtensions: false;
+    constructor(options: FixedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare class $RefVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+declare const SchemaVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class SchemaVisitor extends SchemaVisitor_base {
+    readonly element: Schema;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Schema']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
 declare class Xml extends ObjectElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
     get name(): StringElement | undefined;
@@ -934,6 +942,47 @@ declare class Xml extends ObjectElement {
     set wrapped(wrapped: BooleanElement | undefined);
 }
 
+declare const XmlVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class XmlVisitor extends XmlVisitor_base {
+    readonly element: Xml;
+    protected readonly specPath: SpecPath<['document', 'objects', 'XML']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
+}
+
+declare const DefinitionsVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class DefinitionsVisitor extends DefinitionsVisitor_base {
+    readonly element: Definitions;
+    protected readonly specPath: SpecPath<[
+        'document',
+        'objects',
+        'JSONReference'
+    ] | ['document', 'objects', 'Schema']>;
+    constructor(options: MapVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare const ResponsesDefinitionsVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class ResponsesDefinitionsVisitor extends ResponsesDefinitionsVisitor_base {
+    readonly element: ResponsesDefinitions;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Response']>;
+    constructor(options: MapVisitorOptions);
+}
+
+declare const ParametersDefinitionsVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class ParametersDefinitionsVisitor extends ParametersDefinitionsVisitor_base {
+    readonly element: ParametersDefinitions;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Parameter']>;
+    constructor(options: MapVisitorOptions);
+}
+
+declare const SecurityDefinitionsVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class SecurityDefinitionsVisitor extends SecurityDefinitionsVisitor_base {
+    readonly element: SecurityDefinitions;
+    protected readonly specPath: SpecPath<['document', 'objects', 'SecurityScheme']>;
+    constructor(options: MapVisitorOptions);
+}
+
 declare class SecurityScheme extends ObjectElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
     get type(): StringElement | undefined;
@@ -954,14 +1003,459 @@ declare class SecurityScheme extends ObjectElement {
     set scopes(scopes: ArrayElement | undefined);
 }
 
-declare class SecurityRequirement extends ObjectElement {
-    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+declare const SecuritySchemeVisitor_base: ts_mixer_dist_types_types.Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+declare class SecuritySchemeVisitor extends SecuritySchemeVisitor_base {
+    readonly element: SecurityScheme;
+    protected readonly specPath: SpecPath<['document', 'objects', 'SecurityScheme']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FixedFieldsVisitorOptions);
 }
 
 declare class Scopes extends ObjectElement {
     constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
 }
 
+declare const ScopesVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class ScopesVisitor extends ScopesVisitor_base {
+    readonly element: Scopes;
+    protected readonly specPath: SpecPath<['value']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: MapVisitorOptions);
+}
+
+declare class SecurityRequirement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+declare const SecurityRequirementVisitor_base: ts_mixer_dist_types_types.Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+declare class SecurityRequirementVisitor extends SecurityRequirementVisitor_base {
+    readonly element: SecurityRequirement;
+    protected readonly specPath: SpecPath<['value']>;
+    constructor(options: MapVisitorOptions);
+}
+
+declare class SpecificationExtensionVisitor extends SpecificationVisitor {
+    element: MemberElement;
+    MemberElement(memberElement: MemberElement): {};
+}
+
+declare const specification: {
+    visitors: {
+        value: typeof FallbackVisitor;
+        document: {
+            objects: {
+                JSONReference: {
+                    $visitor: stampit.default.Stamp<any>;
+                    fixedFields: {
+                        $ref: stampit.default.Stamp<any>;
+                    };
+                };
+                JSONSchema: {
+                    $ref: string;
+                };
+                Swagger: {
+                    $visitor: typeof SwaggerVisitor$1;
+                    fixedFields: {
+                        swagger: typeof SwaggerVisitor;
+                        info: {
+                            $ref: string;
+                        };
+                        host: typeof HostVisitor;
+                        basePath: typeof BasePathVisitor;
+                        schemes: typeof SchemesVisitor$1;
+                        consumes: typeof ConsumesVisitor$1;
+                        produces: typeof ProducesVisitor$1;
+                        paths: {
+                            $ref: string;
+                        };
+                        definitions: {
+                            $ref: string;
+                        };
+                        parameters: {
+                            $ref: string;
+                        };
+                        responses: {
+                            $ref: string;
+                        };
+                        securityDefinitions: {
+                            $ref: string;
+                        };
+                        security: typeof SecurityVisitor$1;
+                        tags: typeof TagsVisitor$1;
+                        externalDocs: {
+                            $ref: string;
+                        };
+                    };
+                };
+                Info: {
+                    $visitor: typeof InfoVisitor;
+                    fixedFields: {
+                        title: {
+                            $ref: string;
+                        };
+                        description: {
+                            $ref: string;
+                        };
+                        termsOfService: {
+                            $ref: string;
+                        };
+                        contact: {
+                            $ref: string;
+                        };
+                        license: {
+                            $ref: string;
+                        };
+                        version: typeof VersionVisitor;
+                    };
+                };
+                Contact: {
+                    $visitor: typeof ContactVisitor;
+                    fixedFields: {
+                        name: {
+                            $ref: string;
+                        };
+                        url: {
+                            $ref: string;
+                        };
+                        email: {
+                            $ref: string;
+                        };
+                    };
+                };
+                License: {
+                    $visitor: typeof LicenseVisitor;
+                    fixedFields: {
+                        name: {
+                            $ref: string;
+                        };
+                        url: {
+                            $ref: string;
+                        };
+                    };
+                };
+                Paths: {
+                    $visitor: typeof PathsVisitor;
+                };
+                PathItem: {
+                    $visitor: typeof PathItemVisitor;
+                    fixedFields: {
+                        $ref: typeof $RefVisitor$1;
+                        get: {
+                            $ref: string;
+                        };
+                        put: {
+                            $ref: string;
+                        };
+                        post: {
+                            $ref: string;
+                        };
+                        delete: {
+                            $ref: string;
+                        };
+                        options: {
+                            $ref: string;
+                        };
+                        head: {
+                            $ref: string;
+                        };
+                        patch: {
+                            $ref: string;
+                        };
+                        parameters: typeof ParametersVisitor$1;
+                    };
+                };
+                Operation: {
+                    $visitor: typeof OperationVisitor;
+                    fixedFields: {
+                        tags: typeof TagsVisitor;
+                        summary: {
+                            $ref: string;
+                        };
+                        description: {
+                            $ref: string;
+                        };
+                        externalDocs: {
+                            $ref: string;
+                        };
+                        operationId: {
+                            $ref: string;
+                        };
+                        consumes: typeof ConsumesVisitor;
+                        produces: typeof ProducesVisitor;
+                        parameters: typeof ParametersVisitor;
+                        responses: {
+                            $ref: string;
+                        };
+                        schemes: typeof SchemesVisitor;
+                        deprecated: {
+                            $ref: string;
+                        };
+                        security: typeof SecurityVisitor;
+                    };
+                };
+                ExternalDocumentation: {
+                    $visitor: typeof ExternalDocumentationVisitor;
+                    fixedFields: {
+                        description: {
+                            $ref: string;
+                        };
+                        url: {
+                            $ref: string;
+                        };
+                    };
+                };
+                Parameter: {
+                    $visitor: typeof ParameterVisitor;
+                    fixedFields: {
+                        name: {
+                            $ref: string;
+                        };
+                        in: {
+                            $ref: string;
+                        };
+                        description: stampit.default.Stamp<any>;
+                        required: stampit.default.Stamp<any>;
+                        schema: stampit.default.Stamp<any>;
+                        type: stampit.default.Stamp<any>;
+                        format: stampit.default.Stamp<any>;
+                        items: {
+                            $ref: string;
+                        };
+                        collectionFormat: {
+                            $ref: string;
+                        };
+                        default: stampit.default.Stamp<any>;
+                        maximum: stampit.default.Stamp<any>;
+                        exclusiveMaximum: stampit.default.Stamp<any>;
+                        minimum: stampit.default.Stamp<any>;
+                        exclusiveMinimum: stampit.default.Stamp<any>;
+                        maxLength: stampit.default.Stamp<any>;
+                        minLength: stampit.default.Stamp<any>;
+                        pattern: stampit.default.Stamp<any>;
+                        maxItems: stampit.default.Stamp<any>;
+                        minItems: stampit.default.Stamp<any>;
+                        uniqueItems: stampit.default.Stamp<any>;
+                        enum: stampit.default.Stamp<any>;
+                        multipleOf: stampit.default.Stamp<any>;
+                    };
+                };
+                Items: {
+                    $visitor: typeof ItemsVisitor;
+                    fixedFields: {
+                        type: stampit.default.Stamp<any>;
+                        format: stampit.default.Stamp<any>;
+                        items: {
+                            $ref: string;
+                        };
+                        collectionFormat: {
+                            $ref: string;
+                        };
+                        default: stampit.default.Stamp<any>;
+                        maximum: stampit.default.Stamp<any>;
+                        exclusiveMaximum: stampit.default.Stamp<any>;
+                        minimum: stampit.default.Stamp<any>;
+                        exclusiveMinimum: stampit.default.Stamp<any>;
+                        maxLength: stampit.default.Stamp<any>;
+                        minLength: stampit.default.Stamp<any>;
+                        pattern: stampit.default.Stamp<any>;
+                        maxItems: stampit.default.Stamp<any>;
+                        minItems: stampit.default.Stamp<any>;
+                        uniqueItems: stampit.default.Stamp<any>;
+                        enum: stampit.default.Stamp<any>;
+                        multipleOf: stampit.default.Stamp<any>;
+                    };
+                };
+                Responses: {
+                    $visitor: typeof ResponsesVisitor;
+                    fixedFields: {
+                        default: typeof DefaultVisitor;
+                    };
+                };
+                Response: {
+                    $visitor: typeof ResponseVisitor;
+                    fixedFields: {
+                        description: {
+                            $ref: string;
+                        };
+                        schema: stampit.default.Stamp<any>;
+                        headers: {
+                            $ref: string;
+                        };
+                        examples: {
+                            $ref: string;
+                        };
+                    };
+                };
+                Headers: {
+                    $visitor: typeof HeadersVisitor;
+                };
+                Example: {
+                    $visitor: typeof ExampleVisitor;
+                };
+                Header: {
+                    $visitor: typeof HeaderVisitor;
+                    fixedFields: {
+                        description: stampit.default.Stamp<any>;
+                        type: stampit.default.Stamp<any>;
+                        format: stampit.default.Stamp<any>;
+                        items: {
+                            $ref: string;
+                        };
+                        collectionFormat: {
+                            $ref: string;
+                        };
+                        default: stampit.default.Stamp<any>;
+                        maximum: stampit.default.Stamp<any>;
+                        exclusiveMaximum: stampit.default.Stamp<any>;
+                        minimum: stampit.default.Stamp<any>;
+                        exclusiveMinimum: stampit.default.Stamp<any>;
+                        maxLength: stampit.default.Stamp<any>;
+                        minLength: stampit.default.Stamp<any>;
+                        pattern: stampit.default.Stamp<any>;
+                        maxItems: stampit.default.Stamp<any>;
+                        minItems: stampit.default.Stamp<any>;
+                        uniqueItems: stampit.default.Stamp<any>;
+                        enum: stampit.default.Stamp<any>;
+                        multipleOf: stampit.default.Stamp<any>;
+                    };
+                };
+                Tag: {
+                    $visitor: typeof TagVisitor;
+                    fixedFields: {
+                        name: {
+                            $ref: string;
+                        };
+                        description: {
+                            $ref: string;
+                        };
+                        externalDocs: {
+                            $ref: string;
+                        };
+                    };
+                };
+                Reference: {
+                    $visitor: typeof ReferenceVisitor;
+                    fixedFields: {
+                        $ref: typeof $RefVisitor;
+                    };
+                };
+                Schema: {
+                    $visitor: typeof SchemaVisitor;
+                    fixedFields: {
+                        format: stampit.default.Stamp<any>;
+                        title: stampit.default.Stamp<any>;
+                        description: stampit.default.Stamp<any>;
+                        default: stampit.default.Stamp<any>;
+                        multipleOf: stampit.default.Stamp<any>;
+                        maximum: stampit.default.Stamp<any>;
+                        exclusiveMaximum: stampit.default.Stamp<any>;
+                        minimum: stampit.default.Stamp<any>;
+                        exclusiveMinimum: stampit.default.Stamp<any>;
+                        maxLength: stampit.default.Stamp<any>;
+                        minLength: stampit.default.Stamp<any>;
+                        pattern: stampit.default.Stamp<any>;
+                        maxItems: stampit.default.Stamp<any>;
+                        minItems: stampit.default.Stamp<any>;
+                        uniqueItems: stampit.default.Stamp<any>;
+                        maxProperties: stampit.default.Stamp<any>;
+                        minProperties: stampit.default.Stamp<any>;
+                        required: stampit.default.Stamp<any>;
+                        enum: stampit.default.Stamp<any>;
+                        type: stampit.default.Stamp<any>;
+                        readOnly: stampit.default.Stamp<any>;
+                        items: stampit.default.Stamp<any>;
+                        allOf: stampit.default.Stamp<any>;
+                        properties: stampit.default.Stamp<any>;
+                        additionalProperties: stampit.default.Stamp<any>;
+                        discriminator: {
+                            $ref: string;
+                        };
+                        xml: {
+                            $ref: string;
+                        };
+                        externalDocs: {
+                            $ref: string;
+                        };
+                        example: {
+                            $ref: string;
+                        };
+                    };
+                };
+                XML: {
+                    $visitor: typeof XmlVisitor;
+                    fixedFields: {
+                        name: {
+                            $ref: string;
+                        };
+                        namespace: {
+                            $ref: string;
+                        };
+                        prefix: {
+                            $ref: string;
+                        };
+                        attribute: {
+                            $ref: string;
+                        };
+                        wrapped: {
+                            $ref: string;
+                        };
+                    };
+                };
+                Definitions: {
+                    $visitor: typeof DefinitionsVisitor;
+                };
+                ParametersDefinitions: {
+                    $visitor: typeof ParametersDefinitionsVisitor;
+                };
+                ResponsesDefinitions: {
+                    $visitor: typeof ResponsesDefinitionsVisitor;
+                };
+                SecurityDefinitions: {
+                    $visitor: typeof SecurityDefinitionsVisitor;
+                };
+                SecurityScheme: {
+                    $visitor: typeof SecuritySchemeVisitor;
+                    fixedFields: {
+                        type: {
+                            $ref: string;
+                        };
+                        description: {
+                            $ref: string;
+                        };
+                        name: {
+                            $ref: string;
+                        };
+                        in: {
+                            $ref: string;
+                        };
+                        flow: {
+                            $ref: string;
+                        };
+                        authorizationUrl: {
+                            $ref: string;
+                        };
+                        token: {
+                            $ref: string;
+                        };
+                        scopes: {
+                            $ref: string;
+                        };
+                    };
+                };
+                Scopes: {
+                    $visitor: typeof ScopesVisitor;
+                };
+                SecurityRequirement: {
+                    $visitor: typeof SecurityRequirementVisitor;
+                };
+            };
+            extension: {
+                $visitor: typeof SpecificationExtensionVisitor;
+            };
+        };
+    };
+};
+
 declare const isSwaggerElement: _swagger_api_apidom_core.ElementPredicate<Swagger>;
 declare const isSwaggerVersionElement: _swagger_api_apidom_core.ElementPredicate<SwaggerVersion>;
 declare const isInfoElement: _swagger_api_apidom_core.ElementPredicate<Info>;
@@ -990,38 +1484,6 @@ declare const isSecuritySchemeElement: _swagger_api_apidom_core.ElementPredicate
 declare const isScopesElement: _swagger_api_apidom_core.ElementPredicate<Scopes>;
 declare const isSecurityRequirementElement: _swagger_api_apidom_core.ElementPredicate<SecurityRequirement>;
 
-interface ReferenceLikeElement extends ObjectElement {
-    hasKey: (value: '$ref') => true;
-}
-declare const isSwaggerExtension: (element: MemberElement) => boolean;
-declare const isReferenceLikeElement: (element: unknown) => element is ReferenceLikeElement;
-
-declare const AlternatingVisitor: stampit__default.Stamp<any>;
-
-declare const FixedFieldsVisitor: stampit__default.Stamp<any>;
-
-declare const MapVisitor: stampit__default.Stamp<any>;
-
-declare const MixedFieldsVisitor: stampit__default.Stamp<any>;
-
-declare const PatternedFieldsJsonObjectVisitor: stampit__default.Stamp<any>;
-
-/**
- * This visitor is responsible for falling back to current traversed element
- * Given OpenApi3_0Visitor expects ObjectElement to be traversed. If
- * different Element is provided FallBackVisitor is responsible to assigning
- * this Element as current element.
- */
-declare const FallbackVisitor: stampit__default.Stamp<any>;
-
-/**
- * This is a base Type for every visitor that does
- * internal look-ups to retrieve other child visitors.
- */
-declare const SpecificationVisitor: stampit__default.Stamp<any>;
-
-declare const Visitor: stampit__default.Stamp<any>;
-
 declare const getNodeType: <T extends Element>(element: T) => string | undefined;
 /**
  * There are unfortunately two `LinkElement` types. One is from base namespace
@@ -1075,64 +1537,4 @@ declare const keyMap: {
     SecurityRequirementElement: string[];
 };
 
-declare class OperationConsumes extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class OperationParameters extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class OperationProduces extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class OperationSchemes extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class OperationSecurity extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class OperationTags extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class PathItemParameters extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class SwaggerSchemes extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class SwaggerConsumes extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class SwaggerProduces extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class SwaggerSecurity extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-declare class SwaggerTags extends ArrayElement {
-    static primaryClass: string;
-    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
-}
-
-export { AlternatingVisitor, Contact as ContactElement, Definitions as DefinitionsElement, Example as ExampleElement, ExternalDocumentation as ExternalDocumentationElement, FallbackVisitor, FixedFieldsVisitor, Header as HeaderElement, Headers as HeadersElement, Info as InfoElement, Items as ItemsElement, License as LicenseElement, MapVisitor, MixedFieldsVisitor, OpenAPIMediaTypes, OperationConsumes as OperationConsumesElement, Operation as OperationElement, OperationParameters as OperationParametersElement, OperationProduces as OperationProducesElement, OperationSchemes as OperationSchemesElement, OperationSecurity as OperationSecurityElement, OperationTags as OperationTagsElement, Parameter as ParameterElement, ParametersDefinitions as ParametersDefinitionsElement, PathItem as PathItemElement, PathItemParameters as PathItemParametersElement, Paths as PathsElement, PatternedFieldsJsonObjectVisitor as PatternedFieldsVisitor, Reference as ReferenceElement, Response as ResponseElement, ResponsesDefinitions as ResponsesDefinitionsElement, Responses as ResponsesElement, Schema as SchemaElement, Scopes as ScopesElement, SecurityDefinitions as SecurityDefinitionsElement, SecurityRequirement as SecurityRequirementElement, SecurityScheme as SecuritySchemeElement, SpecificationVisitor, SwaggerConsumes as SwaggerConsumesElement, Swagger as SwaggerElement, SwaggerProduces as SwaggerProducesElement, SwaggerSchemes as SwaggerSchemesElement, SwaggerSecurity as SwaggerSecurityElement, SwaggerTags as SwaggerTagsElement, SwaggerVersion as SwaggerVersionElement, Tag as TagElement, Visitor, Xml as XmlElement, createRefractor, openApi2 as default, getNodeType, isContactElement, isDefinitionsElement, isExampleElement, isExternalDocumentationElement, isHeaderElement, isHeadersElement, isInfoElement, isItemsElement, isLicenseElement, isOperationElement, isParameterElement, isParametersDefinitionsElement, isPathItemElement, isPathsElement, isReferenceElement, isReferenceLikeElement, isResponseElement, isResponsesDefinitionsElement, isResponsesElement, isSchemaElement, isScopesElement, isSecurityDefinitionsElement, isSecurityRequirementElement, isSecuritySchemeElement, isSwaggerElement, isSwaggerExtension, isSwaggerVersionElement, isTagElement, isXmlElement, keyMap, mediaTypes, refract, plugin as refractorPluginReplaceEmptyElement, specification as specificationObj };
+export { AlternatingVisitor, Contact as ContactElement, Definitions as DefinitionsElement, Example as ExampleElement, ExternalDocumentation as ExternalDocumentationElement, FallbackVisitor, FixedFieldsVisitor, Header as HeaderElement, Headers as HeadersElement, Info as InfoElement, Items as ItemsElement, License as LicenseElement, MapVisitor, MixedFieldsVisitor, OpenAPIMediaTypes, OperationConsumes as OperationConsumesElement, Operation as OperationElement, OperationParameters as OperationParametersElement, OperationProduces as OperationProducesElement, OperationSchemes as OperationSchemesElement, OperationSecurity as OperationSecurityElement, OperationTags as OperationTagsElement, Parameter as ParameterElement, ParametersDefinitions as ParametersDefinitionsElement, PathItem as PathItemElement, PathItemParameters as PathItemParametersElement, Paths as PathsElement, PatternedFieldsVisitor, Reference as ReferenceElement, Response as ResponseElement, ResponsesDefinitions as ResponsesDefinitionsElement, Responses as ResponsesElement, Schema as SchemaElement, Scopes as ScopesElement, SecurityDefinitions as SecurityDefinitionsElement, SecurityRequirement as SecurityRequirementElement, SecurityScheme as SecuritySchemeElement, SpecificationVisitor, SwaggerConsumes as SwaggerConsumesElement, Swagger as SwaggerElement, SwaggerProduces as SwaggerProducesElement, SwaggerSchemes as SwaggerSchemesElement, SwaggerSecurity as SwaggerSecurityElement, SwaggerTags as SwaggerTagsElement, SwaggerVersion as SwaggerVersionElement, Tag as TagElement, Visitor, Xml as XmlElement, createRefractor, openApi2 as default, getNodeType, isContactElement, isDefinitionsElement, isExampleElement, isExternalDocumentationElement, isHeaderElement, isHeadersElement, isInfoElement, isItemsElement, isLicenseElement, isOperationElement, isParameterElement, isParametersDefinitionsElement, isPathItemElement, isPathsElement, isReferenceElement, isReferenceLikeElement, isResponseElement, isResponsesDefinitionsElement, isResponsesElement, isSchemaElement, isScopesElement, isSecurityDefinitionsElement, isSecurityRequirementElement, isSecuritySchemeElement, isSwaggerElement, isSwaggerExtension, isSwaggerVersionElement, isTagElement, isXmlElement, keyMap, mediaTypes, refract, plugin as refractorPluginReplaceEmptyElement, specification as specificationObj };