@speclynx/apidom-ns-arazzo-1 1.12.1

package/types/apidom-ns-arazzo-1.d.ts

@@ -0,0 +1,1852 @@
+import { AllOfVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { AnyOfVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { ArrayElement } from '@speclynx/apidom-core';
+import { Attributes } from '@speclynx/apidom-core';
+import { Class } from 'ts-mixer/dist/types/types.js';
+import { DefinitionsVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { DependenciesVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { Element as Element_2 } from '@speclynx/apidom-core';
+import { ElementPredicate } from '@speclynx/apidom-core';
+import { EnumVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { isArrayElement } from '@speclynx/apidom-core';
+import { isBooleanElement } from '@speclynx/apidom-core';
+import { isElement } from '@speclynx/apidom-core';
+import { isJSONSchemaElement } from '@speclynx/apidom-ns-json-schema-2020-12';
+import { isLinkElement as isLinkPrimitiveElement } from '@speclynx/apidom-core';
+import { isMemberElement } from '@speclynx/apidom-core';
+import { isNullElement } from '@speclynx/apidom-core';
+import { isNumberElement } from '@speclynx/apidom-core';
+import { isObjectElement } from '@speclynx/apidom-core';
+import { isRefElement } from '@speclynx/apidom-core';
+import { isStringElement } from '@speclynx/apidom-core';
+import { ItemsVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { JSONSchemaElement as JSONSchemaElement_2 } from '@speclynx/apidom-ns-json-schema-2020-12';
+import { default as JSONSchemaVisitor } from '@speclynx/apidom-ns-json-schema-2020-12';
+import { JSONSchemaVisitor as JSONSchemaVisitor_2 } from '@speclynx/apidom-ns-json-schema-2020-12';
+import { JSONSchemaVisitorOptions } from '@speclynx/apidom-ns-json-schema-2020-12';
+import { LinksVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { MediaTypes } from '@speclynx/apidom-core';
+import { MemberElement } from '@speclynx/apidom-core';
+import { Meta } from '@speclynx/apidom-core';
+import { Namespace } from 'minim';
+import { NamespacePluginOptions } from '@speclynx/apidom-core';
+import { NumberElement } from '@speclynx/apidom-core';
+import { ObjectElement } from '@speclynx/apidom-core';
+import { OneOfVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { PatternPropertiesVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { PropertiesVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { RequiredVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { SchemaOrReferenceVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+import { StringElement } from '@speclynx/apidom-core';
+import { TypeVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+
+/**
+ * @public
+ */
+declare const arazzo1: {
+    namespace: (options: NamespacePluginOptions) => Namespace;
+};
+export default arazzo1;
+
+/**
+ * @public
+ */
+export declare class ArazzoElement extends StringElement {
+    constructor(content?: string, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class ArazzoJSONSchemaVisitor extends JSONSchemaVisitor_2 {
+    element: JSONSchemaElement;
+    constructor(options: JSONSchemaVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare class ArazzoMediaTypes extends MediaTypes<string> {
+    filterByFormat(format?: Format): string[];
+    findBy(version?: string, format?: Format): string;
+    latest(format?: Format): string;
+}
+
+/**
+ * @public
+ */
+export declare class ArazzoSourceDescriptionsVisitor extends SourceDescriptionsVisitor_base {
+    readonly element: SourceDescriptionsElement;
+    constructor(options: ArazzoSourceDescriptionsVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface ArazzoSourceDescriptionsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ArazzoSpecification1Element extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get arazzo(): ArazzoElement | undefined;
+    set arazzo(arazzo: ArazzoElement | undefined);
+    get info(): InfoElement | undefined;
+    set info(info: InfoElement | undefined);
+    get sourceDescriptions(): SourceDescriptionsElement | undefined;
+    set sourceDescriptions(sourceDescriptions: SourceDescriptionsElement | undefined);
+    get workflows(): WorkflowsElement | undefined;
+    set workflows(workflows: WorkflowsElement | undefined);
+    get components(): ComponentsElement | undefined;
+    set components(components: ComponentsElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class ArazzoSpecificationVisitor extends ArazzoSpecificationVisitor_base {
+    readonly element: ArazzoSpecification1Element;
+    protected readonly specPath: SpecPath<['document', 'objects', 'ArazzoSpecification']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: ArazzoSpecificationVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare const ArazzoSpecificationVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface ArazzoSpecificationVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ArazzoStepsVisitor extends StepsVisitor_base {
+    readonly element: WorkflowStepsElement;
+    constructor(options: ArazzoStepsVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface ArazzoStepsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ArazzoVisitor extends ArazzoVisitor_base {
+    element: ArazzoElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+declare const ArazzoVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface ArazzoVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get inputs(): ComponentsInputsElement | undefined;
+    set inputs(inputs: ComponentsInputsElement | undefined);
+    get parameters(): ComponentsParametersElement | undefined;
+    set parameters(parameters: ComponentsParametersElement | undefined);
+    get successActions(): ComponentsSuccessActionsElement | undefined;
+    set successActions(successActions: ComponentsSuccessActionsElement | undefined);
+    get failureActions(): ComponentsFailureActionsElement | undefined;
+    set failureActions(failureActions: ComponentsFailureActionsElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsFailureActionsElement extends ObjectElement {
+    static primaryClass: string;
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsFailureActionsVisitor extends FailureActionsVisitor_base_2 {
+    readonly element: ComponentsFailureActionsElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'FailureAction']>;
+    constructor(options: ComponentsFailureActionsVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface ComponentsFailureActionsVisitorOptions extends MapVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsInputsElement extends ObjectElement {
+    static primaryClass: string;
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsInputsVisitor extends InputsVisitor_base {
+    readonly element: ComponentsInputsElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'JSONSchema']>;
+    constructor(options: ComponentsInputsVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface ComponentsInputsVisitorOptions extends MapVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsParametersElement extends ObjectElement {
+    static primaryClass: string;
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsParametersVisitor extends ParametersVisitor_base {
+    readonly element: ComponentsParametersElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Parameter']>;
+    constructor(options: ComponentsParametersVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface ComponentsParametersVisitorOptions extends MapVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsSuccessActionsElement extends ObjectElement {
+    static primaryClass: string;
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsSuccessActionsVisitor extends SuccessActionsVisitor_base_2 {
+    readonly element: ComponentsSuccessActionsElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'SuccessAction']>;
+    constructor(options: ComponentsSuccessActionsVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface ComponentsSuccessActionsVisitorOptions extends MapVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ComponentsVisitor extends ComponentsVisitor_base {
+    readonly element: ComponentsElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Components']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: ComponentsVisitorOptions);
+}
+
+declare const ComponentsVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface ComponentsVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare const createRefractor: (specPath: string[]) => (value: unknown, options?: {}) => Element_2;
+
+declare const CriteriaVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const CriteriaVisitor_base_2: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare class CriterionElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get context(): StringElement | undefined;
+    set context(context: StringElement | undefined);
+    get condition(): StringElement | undefined;
+    set condition(condition: StringElement | undefined);
+    get type(): StringElement | CriterionExpressionTypeElement | undefined;
+    set type(type: StringElement | CriterionExpressionTypeElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class CriterionExpressionTypeElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get type(): StringElement | undefined;
+    set type(type: StringElement | undefined);
+    get version(): StringElement | undefined;
+    set version(version: StringElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class CriterionExpressionTypeVersionVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+/**
+ * @public
+ */
+export declare class CriterionExpressionTypeVisitor extends CriterionExpressionTypeVisitor_base {
+    readonly element: CriterionExpressionTypeElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'CriterionExpressionType']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: CriterionExpressionTypeVisitorOptions);
+}
+
+declare const CriterionExpressionTypeVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface CriterionExpressionTypeVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class CriterionTypeVisitor extends TypeVisitor_base {
+    readonly element: StringElement | CriterionExpressionTypeElement;
+    ObjectElement(objectElement: ObjectElement): CriterionExpressionTypeElement;
+}
+
+/**
+ * @public
+ */
+export declare interface CriterionTypeVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class CriterionVisitor extends CriterionVisitor_base {
+    readonly element: CriterionElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Criterion']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: CriterionVisitorOptions);
+}
+
+declare const CriterionVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface CriterionVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class FailureActionCriteriaElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class FailureActionCriteriaVisitor extends CriteriaVisitor_base_2 {
+    readonly element: FailureActionCriteriaElement;
+    constructor(options: FailureActionCriteriaVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface FailureActionCriteriaVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class FailureActionElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get name(): StringElement | undefined;
+    set name(name: StringElement | undefined);
+    get type(): StringElement | undefined;
+    set type(type: StringElement | undefined);
+    get workflowId(): StringElement | undefined;
+    set workflowId(workflowId: StringElement | undefined);
+    get stepId(): StringElement | undefined;
+    set stepId(stepId: StringElement | undefined);
+    get retryAfter(): NumberElement | undefined;
+    set retryAfter(retryAfter: NumberElement | undefined);
+    get retryLimit(): NumberElement | undefined;
+    set retryLimit(retryLimit: NumberElement | undefined);
+    get criteria(): FailureActionCriteriaElement | undefined;
+    set criteria(criteria: FailureActionCriteriaElement | undefined);
+}
+
+declare const FailureActionsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const FailureActionsVisitor_base_2: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare class FailureActionVisitor extends FailureActionVisitor_base {
+    readonly element: FailureActionElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'FailureAction']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: FailureActionVisitorOptions);
+}
+
+declare const FailureActionVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface FailureActionVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class FallbackVisitor extends Visitor {
+    enter(element: Element_2): {};
+}
+
+/**
+ * @public
+ */
+export declare class FixedFieldsVisitor extends SpecificationVisitor {
+    protected specPath: SpecPath;
+    protected ignoredFields: string[];
+    protected canSupportSpecificationExtensions: boolean;
+    protected specificationExtensionPredicate: (element: MemberElement) => boolean;
+    constructor({ specPath, ignoredFields, canSupportSpecificationExtensions, specificationExtensionPredicate, ...rest }: FixedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface FixedFieldsVisitorOptions extends SpecificationVisitorOptions {
+    readonly specPath: SpecPath;
+    readonly ignoredFields?: string[];
+    readonly canSupportSpecificationExtensions?: boolean;
+    readonly specificationExtensionPredicate?: typeof isArazzoSpecificationExtension;
+}
+
+/**
+ * @public
+ */
+export declare type Format = 'generic' | 'json' | 'yaml';
+
+/**
+ * @public
+ */
+export declare const getNodeType: <T extends Element_2>(element: T) => string | undefined;
+
+/**
+ * @public
+ */
+export declare class InfoElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    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 version(): StringElement | undefined;
+    set version(version: StringElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class InfoVersionVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+/**
+ * @public
+ */
+export declare class InfoVisitor extends InfoVisitor_base {
+    readonly element: InfoElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Info']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: InfoVisitorOptions);
+}
+
+declare const InfoVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface InfoVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+declare const InputsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare const isArazzoElement: ElementPredicate<ArazzoElement>;
+
+/**
+ * @public
+ */
+export declare const isArazzoSpecification1Element: ElementPredicate<ArazzoSpecification1Element>;
+
+/**
+ * @public
+ */
+export declare const isArazzoSpecificationExtension: (element: MemberElement) => boolean;
+
+export { isArrayElement }
+
+export { isBooleanElement }
+
+/**
+ * @public
+ */
+export declare const isComponentsElement: ElementPredicate<ComponentsElement>;
+
+/**
+ * @public
+ */
+export declare const isComponentsFailureActionsElement: ElementPredicate<ComponentsFailureActionsElement>;
+
+/**
+ * @public
+ */
+export declare const isComponentsInputsElement: ElementPredicate<ComponentsInputsElement>;
+
+/**
+ * @public
+ */
+export declare const isComponentsParametersElement: ElementPredicate<ComponentsParametersElement>;
+
+/**
+ * @public
+ */
+export declare const isComponentsSuccessActionsElement: ElementPredicate<ComponentsSuccessActionsElement>;
+
+/**
+ * @public
+ */
+export declare const isCriterionElement: ElementPredicate<CriterionElement>;
+
+/**
+ * @public
+ */
+export declare const isCriterionExpressionTypeElement: ElementPredicate<CriterionExpressionTypeElement>;
+
+export { isElement }
+
+/**
+ * @public
+ */
+export declare const isFailureActionCriteriaElement: ElementPredicate<FailureActionCriteriaElement>;
+
+/**
+ * @public
+ */
+export declare const isFailureActionElement: ElementPredicate<FailureActionElement>;
+
+/**
+ * @public
+ */
+export declare const isInfoElement: ElementPredicate<InfoElement>;
+
+export { isJSONSchemaElement }
+
+export { isLinkPrimitiveElement }
+
+export { isMemberElement }
+
+export { isNullElement }
+
+export { isNumberElement }
+
+export { isObjectElement }
+
+/**
+ * @public
+ */
+export declare const isParameterElement: ElementPredicate<ParameterElement>;
+
+/**
+ * @public
+ */
+export declare const isPayloadReplacementElement: ElementPredicate<PayloadReplacementElement>;
+
+export { isRefElement }
+
+/**
+ * @public
+ */
+export declare const isRequestBodyElement: ElementPredicate<RequestBodyElement>;
+
+/**
+ * @public
+ */
+export declare const isRequestBodyReplacementsElement: ElementPredicate<RequestBodyReplacementsElement>;
+
+/**
+ * @public
+ */
+export declare const isReusableElement: ElementPredicate<ReusableElement>;
+
+/**
+ * @public
+ */
+export declare const isSourceDescriptionElement: ElementPredicate<SourceDescriptionElement>;
+
+/**
+ * @public
+ */
+export declare const isSourceDescriptionsElement: ElementPredicate<SourceDescriptionsElement>;
+
+/**
+ * @public
+ */
+export declare const isStepDependsOnElement: ElementPredicate<StepDependsOnElement>;
+
+/**
+ * @public
+ */
+export declare const isStepElement: ElementPredicate<StepElement>;
+
+/**
+ * @public
+ */
+export declare const isStepOnFailureElement: ElementPredicate<StepOnFailureElement>;
+
+/**
+ * @public
+ */
+export declare const isStepOnSuccessElement: ElementPredicate<StepOnSuccessElement>;
+
+/**
+ * @public
+ */
+export declare const isStepOutputsElement: ElementPredicate<StepOutputsElement>;
+
+/**
+ * @public
+ */
+export declare const isStepParametersElement: ElementPredicate<StepParametersElement>;
+
+/**
+ * @public
+ */
+export declare const isStepSuccessCriteriaElement: ElementPredicate<StepSuccessCriteriaElement>;
+
+export { isStringElement }
+
+/**
+ * @public
+ */
+export declare const isSuccessActionCriteriaElement: ElementPredicate<SuccessActionCriteriaElement>;
+
+/**
+ * @public
+ */
+export declare const isSuccessActionElement: ElementPredicate<SuccessActionElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowDependsOnElement: ElementPredicate<WorkflowDependsOnElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowElement: ElementPredicate<WorkflowElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowFailureActionsElement: ElementPredicate<WorkflowFailureActionsElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowOutputsElement: ElementPredicate<WorkflowOutputsElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowParametersElement: ElementPredicate<WorkflowParametersElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowsElement: ElementPredicate<WorkflowsElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowStepsElement: ElementPredicate<WorkflowStepsElement>;
+
+/**
+ * @public
+ */
+export declare const isWorkflowSuccessActionsElement: ElementPredicate<WorkflowSuccessActionsElement>;
+
+/**
+ * @public
+ */
+export declare class JSONSchemaElement extends JSONSchemaElement_2 {
+}
+
+export { JSONSchemaVisitor }
+
+export { JSONSchemaVisitorOptions as ArazzoJSONSchemaVisitorOptions }
+export { JSONSchemaVisitorOptions }
+
+/**
+ * Arazzo Specification 1.0.1
+ * @public
+ */
+export declare const keyMap: {
+    ObjectElement: string[];
+    ArrayElement: string[];
+    MemberElement: string[];
+    StringElement: never[];
+    BooleanElement: never[];
+    NumberElement: never[];
+    NullElement: never[];
+    RefElement: never[];
+    LinkElement: never[];
+    Annotation: never[];
+    Comment: never[];
+    ParseResultElement: string[];
+    SourceMap: string[];
+    ArazzoSpecification1Element: string[];
+    ComponentsElement: string[];
+    CriterionElement: string[];
+    CriterionExpressionTypeElement: string[];
+    FailureActionElement: string[];
+    InfoElement: string[];
+    ParameterElement: string[];
+    PayloadReplacementElement: string[];
+    RequestBodyElement: string[];
+    ReusableElement: string[];
+    SourceDescriptionElement: string[];
+    StepElement: string[];
+    SuccessActionElement: string[];
+    WorkflowElement: string[];
+    JSONSchema202012Element: string[];
+};
+
+/**
+ * @public
+ */
+export declare class MapVisitor extends PatternedFieldsVisitor {
+    constructor(options: MapVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface MapVisitorOptions extends PatternedFieldsVisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare const mediaTypes: ArazzoMediaTypes;
+
+declare const OnFailureVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const OnSuccessVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const OutputsVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+
+declare const OutputsVisitor_base_2: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare class ParameterElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get name(): StringElement | undefined;
+    set name(name: StringElement | undefined);
+    get in(): StringElement | undefined;
+    set in(val: StringElement | undefined);
+    get value(): Element_2 | undefined;
+    set value(value: Element_2 | undefined);
+}
+
+declare const ParametersActionsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const ParametersActionsVisitor_base_2: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const ParametersVisitor_base: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare class ParameterVisitor extends ParameterVisitor_base {
+    readonly element: ParameterElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Parameter']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: ParameterVisitorOptions);
+}
+
+declare const ParameterVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface ParameterVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class PatternedFieldsVisitor extends SpecificationVisitor {
+    protected specPath: SpecPath;
+    protected ignoredFields: string[];
+    protected fieldPatternPredicate: (value: unknown) => boolean;
+    protected canSupportSpecificationExtensions: boolean;
+    protected specificationExtensionPredicate: (element: MemberElement) => boolean;
+    constructor({ specPath, ignoredFields, fieldPatternPredicate, canSupportSpecificationExtensions, specificationExtensionPredicate, ...rest }: PatternedFieldsVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface PatternedFieldsVisitorOptions extends SpecificationVisitorOptions {
+    readonly specPath: SpecPath;
+    readonly ignoredFields?: string[];
+    readonly fieldPatternPredicate?: (...args: unknown[]) => boolean;
+    readonly canSupportSpecificationExtensions?: boolean;
+    readonly specificationExtensionPredicate?: typeof isArazzoSpecificationExtension;
+}
+
+/**
+ * @public
+ */
+export declare class PayloadReplacementElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get target(): StringElement | undefined;
+    set target(target: StringElement | undefined);
+    get value(): Element_2 | undefined;
+    set value(value: Element_2 | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class PayloadReplacementVisitor extends PayloadReplacementVisitor_base {
+    readonly element: PayloadReplacementElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'PayloadReplacement']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: PayloadReplacementVisitorOptions);
+}
+
+declare const PayloadReplacementVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface PayloadReplacementVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare const refract: <T extends Element_2>(value: unknown, { specPath, plugins, }?: {
+    specPath?: string[] | undefined;
+    plugins?: never[] | undefined;
+}) => T;
+
+/**
+ * @public
+ */
+export declare const refractorPluginReplaceEmptyElement: () => () => {
+    visitor: {
+        StringElement(element: StringElement, key: any, parent: any, path: any, ancestors: any[]): any;
+    };
+};
+
+declare const ReplacementsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare class RequestBodyElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get contentType(): StringElement | undefined;
+    set contentType(contentType: StringElement | undefined);
+    get payload(): Element_2 | undefined;
+    set payload(payload: Element_2 | undefined);
+    get replacements(): RequestBodyReplacementsElement | undefined;
+    set replacements(replacements: RequestBodyReplacementsElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class RequestBodyReplacementsElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class RequestBodyReplacementsVisitor extends ReplacementsVisitor_base {
+    readonly element: RequestBodyReplacementsElement;
+    constructor(options: RequestBodyReplacementsVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface RequestBodyReplacementsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class RequestBodyVisitor extends RequestBodyVisitor_base {
+    readonly element: RequestBodyElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'RequestBody']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: RequestBodyVisitorOptions);
+}
+
+declare const RequestBodyVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface RequestBodyVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class ReusableElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get reference(): StringElement | undefined;
+    set reference(reference: StringElement | undefined);
+    get value(): StringElement | undefined;
+    set value(value: StringElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class ReusableReferenceVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+/**
+ * @public
+ */
+export declare class ReusableVisitor extends ReusableVisitor_base {
+    readonly element: ReusableElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Reusable']>;
+    protected readonly canSupportSpecificationExtensions: false;
+    constructor(options: ReusableVisitorOptions);
+    ObjectElement(objectElement: ObjectElement): {};
+}
+
+declare const ReusableVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface ReusableVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class SourceDescriptionElement 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 type(): StringElement | undefined;
+    set type(type: StringElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class SourceDescriptionsElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class SourceDescriptionsUrlVisitor extends FallbackVisitor {
+    readonly element: StringElement;
+    StringElement(stringElement: StringElement): {};
+}
+
+/**
+ * @public
+ */
+export declare class SourceDescriptionsVisitor extends SourceDescriptionVisitor_base {
+    readonly element: SourceDescriptionElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'SourceDescription']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: SourceDescriptionVisitorOptions);
+}
+
+declare const SourceDescriptionsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const SourceDescriptionVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface SourceDescriptionVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class SpecificationExtensionVisitor extends SpecificationVisitor {
+    element: MemberElement;
+    MemberElement(memberElement: MemberElement): {};
+}
+
+/**
+ * @public
+ */
+export declare const specificationObj: {
+    readonly visitors: {
+        readonly value: typeof FallbackVisitor;
+        readonly document: {
+            readonly objects: {
+                readonly ArazzoSpecification: {
+                    readonly $visitor: typeof ArazzoSpecificationVisitor;
+                    readonly fixedFields: {
+                        readonly arazzo: typeof ArazzoVisitor;
+                        readonly info: {
+                            readonly $ref: "#/visitors/document/objects/Info";
+                        };
+                        readonly sourceDescriptions: typeof ArazzoSourceDescriptionsVisitor;
+                        readonly workflows: typeof WorkflowsVisitor;
+                        readonly components: {
+                            readonly $ref: "#/visitors/document/objects/Components";
+                        };
+                    };
+                };
+                readonly Info: {
+                    readonly $visitor: typeof InfoVisitor;
+                    readonly fixedFields: {
+                        readonly title: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly summary: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly description: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly version: typeof InfoVersionVisitor;
+                    };
+                };
+                readonly SourceDescription: {
+                    readonly $visitor: typeof SourceDescriptionsVisitor;
+                    readonly fixedFields: {
+                        readonly name: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly url: typeof SourceDescriptionsUrlVisitor;
+                        readonly type: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                    };
+                };
+                readonly Workflow: {
+                    readonly $visitor: typeof WorkflowVisitor;
+                    readonly fixedFields: {
+                        readonly workflowId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly summary: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly description: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly inputs: typeof ArazzoJSONSchemaVisitor;
+                        readonly dependsOn: typeof WorkflowDependsOnVisitor;
+                        readonly steps: typeof ArazzoStepsVisitor;
+                        readonly successActions: typeof WorkflowSuccessActionsVisitor;
+                        readonly failureActions: typeof WorkflowFailureActionsVisitor;
+                        readonly outputs: typeof WorkflowOutputsVisitor;
+                        readonly parameters: typeof WorkflowParametersVisitor;
+                    };
+                };
+                readonly Step: {
+                    readonly $visitor: typeof StepsVisitor;
+                    readonly fixedFields: {
+                        readonly description: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly stepId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly operationId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly operationPath: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly workflowId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly parameters: typeof StepParametersVisitor;
+                        readonly requestBody: {
+                            readonly $ref: "#/visitors/document/objects/RequestBody";
+                        };
+                        readonly successCriteria: typeof StepSuccessCriteriaVisitor;
+                        readonly onSuccess: typeof StepOnSuccessVisitor;
+                        readonly onFailure: typeof StepOnFailureVisitor;
+                        readonly outputs: typeof StepOutputsVisitor;
+                    };
+                };
+                readonly Parameter: {
+                    readonly $visitor: typeof ParameterVisitor;
+                    readonly fixedFields: {
+                        readonly name: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly in: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly value: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                    };
+                };
+                readonly SuccessAction: {
+                    readonly $visitor: typeof SuccessActionVisitor;
+                    readonly fixedFields: {
+                        readonly name: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly type: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly workflowId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly stepId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly criteria: typeof SuccessActionCriteriaVisitor;
+                    };
+                };
+                readonly FailureAction: {
+                    readonly $visitor: typeof FailureActionVisitor;
+                    readonly fixedFields: {
+                        readonly name: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly type: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly workflowId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly stepId: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly retryAfter: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly retryLimit: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly criteria: typeof FailureActionCriteriaVisitor;
+                    };
+                };
+                readonly Components: {
+                    readonly $visitor: typeof ComponentsVisitor;
+                    readonly fixedFields: {
+                        readonly inputs: typeof ComponentsInputsVisitor;
+                        readonly parameters: typeof ComponentsParametersVisitor;
+                        readonly successActions: typeof ComponentsSuccessActionsVisitor;
+                        readonly failureActions: typeof ComponentsFailureActionsVisitor;
+                    };
+                };
+                readonly Reusable: {
+                    readonly $visitor: typeof ReusableVisitor;
+                    readonly fixedFields: {
+                        readonly reference: typeof ReusableReferenceVisitor;
+                        readonly value: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                    };
+                };
+                readonly Criterion: {
+                    readonly $visitor: typeof CriterionVisitor;
+                    readonly fixedFields: {
+                        readonly context: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly condition: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly type: typeof CriterionTypeVisitor;
+                    };
+                };
+                readonly CriterionExpressionType: {
+                    readonly $visitor: typeof CriterionExpressionTypeVisitor;
+                    readonly fixedFields: {
+                        readonly type: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly version: typeof CriterionExpressionTypeVersionVisitor;
+                    };
+                };
+                readonly RequestBody: {
+                    readonly $visitor: typeof RequestBodyVisitor;
+                    readonly fixedFields: {
+                        readonly contentType: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly payload: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly replacements: typeof RequestBodyReplacementsVisitor;
+                    };
+                };
+                readonly PayloadReplacement: {
+                    readonly $visitor: typeof PayloadReplacementVisitor;
+                    readonly fixedFields: {
+                        readonly target: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                        readonly value: {
+                            readonly $ref: "#/visitors/value";
+                        };
+                    };
+                };
+                readonly JSONSchema: {
+                    readonly $visitor: typeof ArazzoJSONSchemaVisitor;
+                    readonly fixedFields: {
+                        readonly id: {
+                            $ref: string;
+                        };
+                        readonly $schema: {
+                            $ref: string;
+                        };
+                        readonly multipleOf: {
+                            $ref: string;
+                        };
+                        readonly maximum: {
+                            $ref: string;
+                        };
+                        readonly exclusiveMaximum: {
+                            $ref: string;
+                        };
+                        readonly minimum: {
+                            $ref: string;
+                        };
+                        readonly exclusiveMinimum: {
+                            $ref: string;
+                        };
+                        readonly maxLength: {
+                            $ref: string;
+                        };
+                        readonly minLength: {
+                            $ref: string;
+                        };
+                        readonly pattern: {
+                            $ref: string;
+                        };
+                        readonly additionalItems: SchemaOrReferenceVisitor;
+                        readonly items: ItemsVisitor;
+                        readonly maxItems: {
+                            $ref: string;
+                        };
+                        readonly minItems: {
+                            $ref: string;
+                        };
+                        readonly uniqueItems: {
+                            $ref: string;
+                        };
+                        readonly maxProperties: {
+                            $ref: string;
+                        };
+                        readonly minProperties: {
+                            $ref: string;
+                        };
+                        readonly required: RequiredVisitor;
+                        readonly properties: PropertiesVisitor;
+                        readonly additionalProperties: SchemaOrReferenceVisitor;
+                        readonly patternProperties: PatternPropertiesVisitor;
+                        readonly dependencies: DependenciesVisitor;
+                        readonly enum: EnumVisitor;
+                        readonly type: TypeVisitor;
+                        readonly allOf: AllOfVisitor;
+                        readonly anyOf: AnyOfVisitor;
+                        readonly oneOf: OneOfVisitor;
+                        readonly not: SchemaOrReferenceVisitor;
+                        readonly definitions: DefinitionsVisitor;
+                        readonly title: {
+                            $ref: string;
+                        };
+                        readonly description: {
+                            $ref: string;
+                        };
+                        readonly default: {
+                            $ref: string;
+                        };
+                        readonly format: {
+                            $ref: string;
+                        };
+                        readonly base: {
+                            $ref: string;
+                        };
+                        readonly links: LinksVisitor;
+                        readonly media: {
+                            $ref: string;
+                        };
+                        readonly readOnly: {
+                            $ref: string;
+                        };
+                    };
+                };
+            };
+            readonly extension: {
+                readonly $visitor: typeof SpecificationExtensionVisitor;
+            };
+        };
+    };
+};
+
+/**
+ * @public
+ */
+export declare class SpecificationVisitor extends Visitor {
+    protected readonly specObj: typeof specificationObj;
+    protected readonly passingOptionsNames: string[];
+    constructor({ specObj, ...rest }: SpecificationVisitorOptions);
+    retrievePassingOptions(): Pick<this, keyof this>;
+    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 StepDependsOnElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class StepElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get description(): StringElement | undefined;
+    set description(description: StringElement | undefined);
+    get stepId(): StringElement | undefined;
+    set stepId(stepId: StringElement | undefined);
+    get operationId(): StringElement | undefined;
+    set operationId(operationId: StringElement | undefined);
+    get operationPath(): StringElement | undefined;
+    set operationPath(operationPath: StringElement | undefined);
+    get workflowId(): StringElement | undefined;
+    set workflowId(workflowId: StringElement | undefined);
+    get parameters(): StepParametersElement | undefined;
+    set parameters(parameters: StepParametersElement | undefined);
+    get requestBody(): RequestBodyElement | undefined;
+    set requestBody(requestBody: RequestBodyElement | undefined);
+    get successCriteria(): StepSuccessCriteriaElement | undefined;
+    set successCriteria(successCriteria: StepSuccessCriteriaElement | undefined);
+    get onSuccess(): StepOnSuccessElement | undefined;
+    set onSuccess(onSuccess: StepOnSuccessElement | undefined);
+    get onFailure(): StepOnFailureElement | undefined;
+    set onFailure(onFailure: StepOnFailureElement | undefined);
+    get outputs(): StepOutputsElement | undefined;
+    set outputs(outputs: StepOutputsElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class StepOnFailureElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class StepOnFailureVisitor extends OnFailureVisitor_base {
+    readonly element: StepOnFailureElement;
+    constructor(options: StepOnFailureVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface StepOnFailureVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class StepOnSuccessElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class StepOnSuccessVisitor extends OnSuccessVisitor_base {
+    readonly element: StepOnSuccessElement;
+    constructor(options: StepOnSuccessVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface StepOnSuccessVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class StepOutputsElement extends ObjectElement {
+    static primaryClass: string;
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class StepOutputsVisitor extends OutputsVisitor_base_2 {
+    readonly element: StepOutputsElement;
+    protected readonly specPath: SpecPath<['value']>;
+    constructor(options: StepOutputsVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface StepOutputsVisitorOptions extends MapVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class StepParametersElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class StepParametersVisitor extends ParametersActionsVisitor_base_2 {
+    readonly element: StepParametersElement;
+    constructor(options: StepParametersVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface StepParametersVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class StepSuccessCriteriaElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class StepSuccessCriteriaVisitor extends SuccessCriteriaVisitor_base {
+    readonly element: StepSuccessCriteriaElement;
+    constructor(options: StepSuccessCriteriaVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface StepSuccessCriteriaVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class StepsVisitor extends StepVisitor_base {
+    readonly element: StepElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Step']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: StepVisitorOptions);
+}
+
+declare const StepsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const StepVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface StepVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class SuccessActionCriteriaElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class SuccessActionCriteriaVisitor extends CriteriaVisitor_base {
+    readonly element: SuccessActionCriteriaElement;
+    constructor(options: SuccessActionCriteriaVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface SuccessActionCriteriaVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class SuccessActionElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get name(): StringElement | undefined;
+    set name(name: StringElement | undefined);
+    get type(): StringElement | undefined;
+    set type(type: StringElement | undefined);
+    get workflowId(): StringElement | undefined;
+    set workflowId(workflowId: StringElement | undefined);
+    get stepId(): StringElement | undefined;
+    set stepId(stepId: StringElement | undefined);
+    get criteria(): SuccessActionCriteriaElement | undefined;
+    set criteria(criteria: SuccessActionCriteriaElement | undefined);
+}
+
+declare const SuccessActionsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const SuccessActionsVisitor_base_2: Class<any[], MapVisitor & FallbackVisitor, typeof MapVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare class SuccessActionVisitor extends SuccessActionVisitor_base {
+    readonly element: SuccessActionElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'SuccessAction']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: SuccessActionVisitorOptions);
+}
+
+declare const SuccessActionVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface SuccessActionVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+declare const SuccessCriteriaVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+declare const TypeVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare class Visitor {
+    element: Element_2;
+    constructor(options?: VisitorOptions);
+    copyMetaAndAttributes(from: Element_2, to: Element_2): void;
+}
+
+/**
+ * @public
+ */
+declare interface VisitorOptions {
+}
+export { VisitorOptions as CriterionExpressionTypeVersionVisitorOptions }
+export { VisitorOptions as FallbackVisitorOptions }
+export { VisitorOptions as InfoVersionVisitorOptions }
+export { VisitorOptions as ReusableReferenceVisitorOptions }
+export { VisitorOptions as SourceDescriptionsUrlVisitorOptions }
+export { VisitorOptions }
+
+/**
+ * @public
+ */
+export declare class WorkflowDependsOnElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowDependsOnVisitor extends WorkflowDependsOnVisitor_base {
+    readonly element: WorkflowDependsOnElement;
+    constructor(options: WorkflowDependsOnVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare const WorkflowDependsOnVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface WorkflowDependsOnVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowElement extends ObjectElement {
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+    get workflowId(): StringElement | undefined;
+    set workflowId(workflowId: StringElement | undefined);
+    get summary(): StringElement | undefined;
+    set summary(summary: StringElement | undefined);
+    get description(): StringElement | undefined;
+    set description(description: StringElement | undefined);
+    get inputs(): JSONSchemaElement | undefined;
+    set inputs(inputs: JSONSchemaElement | undefined);
+    get dependsOn(): WorkflowDependsOnElement | undefined;
+    set dependsOn(dependsOn: WorkflowDependsOnElement | undefined);
+    get steps(): WorkflowStepsElement | undefined;
+    set steps(steps: WorkflowStepsElement | undefined);
+    get successActions(): WorkflowSuccessActionsElement | undefined;
+    set successActions(successActions: WorkflowSuccessActionsElement | undefined);
+    get failureActions(): WorkflowFailureActionsElement | undefined;
+    set failureActions(failureActions: WorkflowFailureActionsElement | undefined);
+    get outputs(): WorkflowOutputsElement | undefined;
+    set outputs(outputs: WorkflowOutputsElement | undefined);
+    get parameters(): WorkflowParametersElement | undefined;
+    set parameters(parameters: WorkflowParametersElement | undefined);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowFailureActionsElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowFailureActionsVisitor extends FailureActionsVisitor_base {
+    readonly element: WorkflowFailureActionsElement;
+    constructor(options: WorkflowFailureActionsVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface WorkflowFailureActionsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowOutputsElement extends ObjectElement {
+    static primaryClass: string;
+    constructor(content?: Record<string, unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowOutputsVisitor extends OutputsVisitor_base {
+    readonly element: WorkflowOutputsElement;
+    protected readonly specPath: SpecPath<['value']>;
+    constructor(options: WorkflowOutputsVisitorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface WorkflowOutputsVisitorOptions extends MapVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowParametersElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowParametersVisitor extends ParametersActionsVisitor_base {
+    readonly element: WorkflowParametersElement;
+    constructor(options: WorkflowParametersVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface WorkflowParametersVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowsElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowStepsElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowSuccessActionsElement extends ArrayElement {
+    static primaryClass: string;
+    constructor(content?: Array<unknown>, meta?: Meta, attributes?: Attributes);
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowSuccessActionsVisitor extends SuccessActionsVisitor_base {
+    readonly element: WorkflowSuccessActionsElement;
+    constructor(options: WorkflowSuccessActionsVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+/**
+ * @public
+ */
+export declare interface WorkflowSuccessActionsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowsVisitor extends WorkflowsVisitor_base {
+    readonly element: WorkflowsElement;
+    constructor(options: WorkflowsVisitorOptions);
+    ArrayElement(arrayElement: ArrayElement): {};
+}
+
+declare const WorkflowsVisitor_base: Class<any[], SpecificationVisitor & FallbackVisitor, typeof SpecificationVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface WorkflowsVisitorOptions extends SpecificationVisitorOptions, VisitorOptions {
+}
+
+/**
+ * @public
+ */
+export declare class WorkflowVisitor extends WorkflowVisitor_base {
+    readonly element: WorkflowElement;
+    protected readonly specPath: SpecPath<['document', 'objects', 'Workflow']>;
+    protected readonly canSupportSpecificationExtensions: true;
+    constructor(options: WorkflowVisitorOptions);
+}
+
+declare const WorkflowVisitor_base: Class<any[], FixedFieldsVisitor & FallbackVisitor, typeof FixedFieldsVisitor & typeof FallbackVisitor>;
+
+/**
+ * @public
+ */
+export declare interface WorkflowVisitorOptions extends FixedFieldsVisitorOptions, VisitorOptions {
+}
+
+export { }