karavan-core/src/core/model/CamelDefinition.ts

Apache Camel Karavan Core

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Generated by karavan build tools - do NOT edit this file!
 */
import {v4 as uuidv4} from 'uuid';
import {CamelElement} from "./IntegrationDefinition";
export class ProcessorDefinition extends CamelElement {
    stepName?: string = 'processor';
    aggregate?: AggregateDefinition;
    bean?: BeanDefinition | string;
    doCatch?: CatchDefinition;
    choice?: ChoiceDefinition;
    circuitBreaker?: CircuitBreakerDefinition;
    claimCheck?: ClaimCheckDefinition;
    convertBodyTo?: ConvertBodyDefinition | string;
    convertHeaderTo?: ConvertHeaderDefinition;
    convertVariableTo?: ConvertVariableDefinition;
    delay?: DelayDefinition;
    dynamicRouter?: DynamicRouterDefinition;
    enrich?: EnrichDefinition;
    filter?: FilterDefinition;
    doFinally?: FinallyDefinition;
    idempotentConsumer?: IdempotentConsumerDefinition;
    kamelet?: KameletDefinition | string;
    loadBalance?: LoadBalanceDefinition;
    log?: LogDefinition | string;
    loop?: LoopDefinition;
    marshal?: MarshalDefinition;
    multicast?: MulticastDefinition;
    onFallback?: OnFallbackDefinition;
    otherwise?: OtherwiseDefinition;
    pausable?: PausableDefinition;
    pipeline?: PipelineDefinition;
    policy?: PolicyDefinition;
    poll?: PollDefinition | string;
    pollEnrich?: PollEnrichDefinition;
    process?: ProcessDefinition;
    recipientList?: RecipientListDefinition;
    removeHeader?: RemoveHeaderDefinition | string;
    removeHeaders?: RemoveHeadersDefinition | string;
    removeProperties?: RemovePropertiesDefinition | string;
    removeProperty?: RemovePropertyDefinition | string;
    removeVariable?: RemoveVariableDefinition | string;
    resequence?: ResequenceDefinition;
    resumable?: ResumableDefinition;
    rollback?: RollbackDefinition | string;
    routingSlip?: RoutingSlipDefinition | string;
    saga?: SagaDefinition;
    sample?: SamplingDefinition | string;
    script?: ScriptDefinition;
    setBody?: SetBodyDefinition;
    setExchangePattern?: SetExchangePatternDefinition | string;
    setHeader?: SetHeaderDefinition;
    setHeaders?: SetHeadersDefinition;
    setProperty?: SetPropertyDefinition;
    setVariable?: SetVariableDefinition;
    setVariables?: SetVariablesDefinition;
    sort?: SortDefinition;
    split?: SplitDefinition;
    step?: StepDefinition;
    stop?: StopDefinition;
    threads?: ThreadsDefinition;
    throttle?: ThrottleDefinition;
    throwException?: ThrowExceptionDefinition;
    to?: string;
    toD?: string;
    transacted?: TransactedDefinition;
    transform?: TransformDefinition;
    doTry?: TryDefinition;
    unmarshal?: UnmarshalDefinition;
    validate?: ValidateDefinition;
    when?: WhenDefinition;
    whenSkipSendToEndpoint?: WhenSkipSendToEndpointDefinition;
    wireTap?: WireTapDefinition;
    langChain4j?: LangChain4jTokenizerDefinition;
    public constructor(init?: Partial<ProcessorDefinition>) {
        super('ProcessorDefinition');
        Object.assign(this, init);
    }
}

export class BeansDeserializer extends CamelElement {

    public constructor(init?: Partial<BeansDeserializer>) {
        super('BeansDeserializer');
        Object.assign(this, init);
    }
}

export class ErrorHandlerDeserializer extends CamelElement {
    deadLetterChannel?: DeadLetterChannelDefinition;
    defaultErrorHandler?: DefaultErrorHandlerDefinition;
    jtaTransactionErrorHandler?: JtaTransactionErrorHandlerDefinition;
    noErrorHandler?: NoErrorHandlerDefinition;
    refErrorHandler?: RefErrorHandlerDefinition | string;
    springTransactionErrorHandler?: SpringTransactionErrorHandlerDefinition;
    id?: string = 'errorHandlerDeserializer-' + uuidv4().substring(0,4);
    public constructor(init?: Partial<ErrorHandlerDeserializer>) {
        super('ErrorHandlerDeserializer');
        Object.assign(this, init);
    }
}

export class OutputAwareFromDefinition extends CamelElement {
    stepName?: string = 'outputAwareFrom';
    description?: string;
    id?: string = 'outputAwareFrom-' + uuidv4().substring(0,4);
    parameters?: any = {};
    steps: CamelElement[] = [];
    uri: string = '';
    variableReceive?: string;
    public constructor(init?: Partial<OutputAwareFromDefinition>) {
        super('OutputAwareFromDefinition');
        Object.assign(this, init);
    }
}

export class AggregateDefinition extends CamelElement {
    stepName?: string = 'aggregate';
    id?: string = 'aggregate-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    correlationExpression?: ExpressionSubElementDefinition;
    completionPredicate?: ExpressionSubElementDefinition;
    completionTimeoutExpression?: ExpressionSubElementDefinition;
    completionSizeExpression?: ExpressionSubElementDefinition;
    optimisticLockRetryPolicy?: OptimisticLockRetryPolicyDefinition;
    parallelProcessing?: boolean;
    optimisticLocking?: boolean;
    executorService?: string;
    timeoutCheckerExecutorService?: string;
    aggregateController?: string;
    aggregationRepository?: string;
    aggregationStrategy: string = '';
    aggregationStrategyMethodName?: string;
    aggregationStrategyMethodAllowNull?: boolean;
    completionSize?: number;
    completionInterval?: string;
    completionTimeout?: string;
    completionTimeoutCheckerInterval?: string;
    completionFromBatchConsumer?: boolean;
    completionOnNewCorrelationGroup?: boolean;
    eagerCheckCompletion?: boolean;
    ignoreInvalidCorrelationKeys?: boolean;
    closeCorrelationKeyOnCompletion?: number;
    discardOnCompletionTimeout?: boolean;
    discardOnAggregationFailure?: boolean;
    forceCompletionOnStop?: boolean;
    completeAllOnStop?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<AggregateDefinition>) {
        super('AggregateDefinition');
        Object.assign(this, init);
    }
}

export class BeanDefinition extends CamelElement {
    stepName?: string = 'bean';
    id?: string = 'bean-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    ref?: string;
    method?: string;
    beanType?: string;
    scope?: string;
    public constructor(init?: Partial<BeanDefinition>) {
        super('BeanDefinition');
        Object.assign(this, init);
    }
}

export class BeanFactoryDefinition extends CamelElement {
    stepName?: string = 'beanFactory';
    name: string = '';
    type: string = '';
    initMethod?: string;
    destroyMethod?: string;
    factoryMethod?: string;
    factoryBean?: string;
    builderClass?: string;
    builderMethod?: string;
    scriptLanguage?: string;
    constructors?: any = {};
    properties?: any = {};
    script?: string;
    public constructor(init?: Partial<BeanFactoryDefinition>) {
        super('BeanFactoryDefinition');
        Object.assign(this, init);
    }
}

export class CatchDefinition extends CamelElement {
    stepName?: string = 'doCatch';
    id?: string = 'doCatch-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    exception?: string[] = [];
    onWhen?: WhenDefinition;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<CatchDefinition>) {
        super('CatchDefinition');
        Object.assign(this, init);
    }
}

export class ChoiceDefinition extends CamelElement {
    stepName?: string = 'choice';
    id?: string = 'choice-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    when?: WhenDefinition[] = [];
    otherwise?: OtherwiseDefinition;
    precondition?: boolean;
    public constructor(init?: Partial<ChoiceDefinition>) {
        super('ChoiceDefinition');
        Object.assign(this, init);
    }
}

export class CircuitBreakerDefinition extends CamelElement {
    stepName?: string = 'circuitBreaker';
    id?: string = 'circuitBreaker-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    configuration?: string;
    resilience4jConfiguration?: Resilience4jConfigurationDefinition;
    faultToleranceConfiguration?: FaultToleranceConfigurationDefinition;
    onFallback?: OnFallbackDefinition;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<CircuitBreakerDefinition>) {
        super('CircuitBreakerDefinition');
        Object.assign(this, init);
    }
}

export class ClaimCheckDefinition extends CamelElement {
    stepName?: string = 'claimCheck';
    id?: string = 'claimCheck-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    operation?: string;
    key?: string;
    filter?: string;
    aggregationStrategy?: string;
    aggregationStrategyMethodName?: string;
    public constructor(init?: Partial<ClaimCheckDefinition>) {
        super('ClaimCheckDefinition');
        Object.assign(this, init);
    }
}

export class ContextScanDefinition extends CamelElement {
    stepName?: string = 'contextScan';
    includeNonSingletons?: boolean;
    excludes?: string[] = [];
    includes?: string[] = [];
    public constructor(init?: Partial<ContextScanDefinition>) {
        super('ContextScanDefinition');
        Object.assign(this, init);
    }
}

export class ConvertBodyDefinition extends CamelElement {
    stepName?: string = 'convertBodyTo';
    id?: string = 'convertBodyTo-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    type: string = '';
    mandatory?: boolean;
    charset?: string;
    public constructor(init?: Partial<ConvertBodyDefinition>) {
        super('ConvertBodyDefinition');
        Object.assign(this, init);
    }
}

export class ConvertHeaderDefinition extends CamelElement {
    stepName?: string = 'convertHeaderTo';
    id?: string = 'convertHeaderTo-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    type: string = '';
    toName?: string;
    mandatory?: boolean;
    charset?: string;
    public constructor(init?: Partial<ConvertHeaderDefinition>) {
        super('ConvertHeaderDefinition');
        Object.assign(this, init);
    }
}

export class ConvertVariableDefinition extends CamelElement {
    stepName?: string = 'convertVariableTo';
    id?: string = 'convertVariableTo-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    type: string = '';
    toName?: string;
    mandatory?: boolean;
    charset?: string;
    public constructor(init?: Partial<ConvertVariableDefinition>) {
        super('ConvertVariableDefinition');
        Object.assign(this, init);
    }
}

export class DataFormatDefinition extends CamelElement {
    stepName?: string = 'dataFormat';
    id?: string = 'dataFormat-' + uuidv4().substring(0,4);
    public constructor(init?: Partial<DataFormatDefinition>) {
        super('DataFormatDefinition');
        Object.assign(this, init);
    }
}

export class DelayDefinition extends CamelElement {
    stepName?: string = 'delay';
    id?: string = 'delay-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    asyncDelayed?: boolean;
    callerRunsWhenRejected?: boolean;
    executorService?: string;
    public constructor(init?: Partial<DelayDefinition>) {
        super('DelayDefinition');
        Object.assign(this, init);
    }
}

export class DynamicRouterDefinition extends CamelElement {
    stepName?: string = 'dynamicRouter';
    id?: string = 'dynamicRouter-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    uriDelimiter?: string;
    ignoreInvalidEndpoints?: boolean;
    cacheSize?: number;
    public constructor(init?: Partial<DynamicRouterDefinition>) {
        super('DynamicRouterDefinition');
        Object.assign(this, init);
    }
}

export class EnrichDefinition extends CamelElement {
    stepName?: string = 'enrich';
    id?: string = 'enrich-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    variableSend?: string;
    variableReceive?: string;
    aggregationStrategy?: string;
    aggregationStrategyMethodName?: string;
    aggregationStrategyMethodAllowNull?: string;
    aggregateOnException?: boolean;
    shareUnitOfWork?: boolean;
    cacheSize?: number;
    ignoreInvalidEndpoint?: boolean;
    allowOptimisedComponents?: boolean;
    autoStartComponents?: boolean;
    public constructor(init?: Partial<EnrichDefinition>) {
        super('EnrichDefinition');
        Object.assign(this, init);
    }
}

export class ErrorHandlerDefinition extends CamelElement {
    stepName?: string = 'errorHandler';
    id?: string = 'errorHandler-' + uuidv4().substring(0,4);
    deadLetterChannel?: DeadLetterChannelDefinition;
    defaultErrorHandler?: DefaultErrorHandlerDefinition;
    jtaTransactionErrorHandler?: JtaTransactionErrorHandlerDefinition;
    noErrorHandler?: NoErrorHandlerDefinition;
    refErrorHandler?: RefErrorHandlerDefinition | string;
    springTransactionErrorHandler?: SpringTransactionErrorHandlerDefinition;
    public constructor(init?: Partial<ErrorHandlerDefinition>) {
        super('ErrorHandlerDefinition');
        Object.assign(this, init);
    }
}

export class ExpressionSubElementDefinition extends CamelElement {
    stepName?: string = 'expressionSubElement';
    constant?: ConstantExpression | string;
    csimple?: CSimpleExpression | string;
    datasonnet?: DatasonnetExpression | string;
    exchangeProperty?: ExchangePropertyExpression | string;
    groovy?: GroovyExpression | string;
    header?: HeaderExpression | string;
    hl7terser?: Hl7TerserExpression | string;
    java?: JavaExpression | string;
    jq?: JqExpression | string;
    js?: JavaScriptExpression | string;
    jsonpath?: JsonPathExpression | string;
    language?: LanguageExpression;
    method?: MethodCallExpression | string;
    mvel?: MvelExpression | string;
    ognl?: OgnlExpression | string;
    python?: PythonExpression | string;
    ref?: RefExpression | string;
    simple?: SimpleExpression | string;
    spel?: SpELExpression | string;
    tokenize?: TokenizerExpression | string;
    variable?: VariableExpression | string;
    wasm?: WasmExpression | string;
    xpath?: XPathExpression | string;
    xquery?: XQueryExpression | string;
    xtokenize?: XMLTokenizerExpression | string;
    public constructor(init?: Partial<ExpressionSubElementDefinition>) {
        super('ExpressionSubElementDefinition');
        Object.assign(this, init);
    }
}

export class FaultToleranceConfigurationDefinition extends CamelElement {
    stepName?: string = 'faultToleranceConfiguration';
    id?: string = 'faultToleranceConfiguration-' + uuidv4().substring(0,4);
    circuitBreaker?: string;
    delay?: string;
    successThreshold?: number;
    requestVolumeThreshold?: number;
    failureRatio?: number;
    timeoutEnabled?: boolean;
    timeoutDuration?: string;
    timeoutPoolSize?: number;
    timeoutScheduledExecutorService?: string;
    bulkheadEnabled?: boolean;
    bulkheadMaxConcurrentCalls?: number;
    bulkheadWaitingTaskQueue?: number;
    bulkheadExecutorService?: string;
    public constructor(init?: Partial<FaultToleranceConfigurationDefinition>) {
        super('FaultToleranceConfigurationDefinition');
        Object.assign(this, init);
    }
}

export class FilterDefinition extends CamelElement {
    stepName?: string = 'filter';
    id?: string = 'filter-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    statusPropertyName?: string;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<FilterDefinition>) {
        super('FilterDefinition');
        Object.assign(this, init);
    }
}

export class FinallyDefinition extends CamelElement {
    stepName?: string = 'doFinally';
    id?: string = 'doFinally-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<FinallyDefinition>) {
        super('FinallyDefinition');
        Object.assign(this, init);
    }
}

export class FromDefinition extends CamelElement {
    stepName?: string = 'from';
    id?: string = 'from-' + uuidv4().substring(0,4);
    description?: string;
    uri: string = '';
    variableReceive?: string;
    parameters?: any = {};
    steps: CamelElement[] = [];
    public constructor(init?: Partial<FromDefinition>) {
        super('FromDefinition');
        Object.assign(this, init);
    }
}

export class GlobalOptionDefinition extends CamelElement {
    stepName?: string = 'globalOption';
    key: string = '';
    value: string = '';
    public constructor(init?: Partial<GlobalOptionDefinition>) {
        super('GlobalOptionDefinition');
        Object.assign(this, init);
    }
}

export class GlobalOptionsDefinition extends CamelElement {
    stepName?: string = 'globalOptions';
    globalOption?: GlobalOptionDefinition[] = [];
    public constructor(init?: Partial<GlobalOptionsDefinition>) {
        super('GlobalOptionsDefinition');
        Object.assign(this, init);
    }
}

export class IdempotentConsumerDefinition extends CamelElement {
    stepName?: string = 'idempotentConsumer';
    id?: string = 'idempotentConsumer-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    idempotentRepository: string = '';
    eager?: boolean;
    completionEager?: boolean;
    skipDuplicate?: boolean;
    removeOnFailure?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<IdempotentConsumerDefinition>) {
        super('IdempotentConsumerDefinition');
        Object.assign(this, init);
    }
}

export class InputTypeDefinition extends CamelElement {
    stepName?: string = 'inputType';
    id?: string = 'inputType-' + uuidv4().substring(0,4);
    description?: string;
    urn: string = '';
    validate?: boolean;
    public constructor(init?: Partial<InputTypeDefinition>) {
        super('InputTypeDefinition');
        Object.assign(this, init);
    }
}

export class InterceptDefinition extends CamelElement {
    stepName?: string = 'intercept';
    id?: string = 'intercept-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<InterceptDefinition>) {
        super('InterceptDefinition');
        Object.assign(this, init);
    }
}

export class InterceptFromDefinition extends CamelElement {
    stepName?: string = 'interceptFrom';
    id?: string = 'interceptFrom-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    uri?: string;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<InterceptFromDefinition>) {
        super('InterceptFromDefinition');
        Object.assign(this, init);
    }
}

export class InterceptSendToEndpointDefinition extends CamelElement {
    stepName?: string = 'interceptSendToEndpoint';
    id?: string = 'interceptSendToEndpoint-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    uri: string = '';
    skipSendToOriginalEndpoint?: string;
    afterUri?: string;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<InterceptSendToEndpointDefinition>) {
        super('InterceptSendToEndpointDefinition');
        Object.assign(this, init);
    }
}

export class KameletDefinition extends CamelElement {
    stepName?: string = 'kamelet';
    name: string = '';
    parameters?: any = {};
    public constructor(init?: Partial<KameletDefinition>) {
        super('KameletDefinition');
        Object.assign(this, init);
    }
}

export class LoadBalanceDefinition extends CamelElement {
    stepName?: string = 'loadBalance';
    id?: string = 'loadBalance-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    inheritErrorHandler?: boolean;
    customLoadBalancer?: CustomLoadBalancerDefinition | string;
    failoverLoadBalancer?: FailoverLoadBalancerDefinition;
    randomLoadBalancer?: RandomLoadBalancerDefinition;
    roundRobinLoadBalancer?: RoundRobinLoadBalancerDefinition;
    stickyLoadBalancer?: StickyLoadBalancerDefinition;
    topicLoadBalancer?: TopicLoadBalancerDefinition;
    weightedLoadBalancer?: WeightedLoadBalancerDefinition;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<LoadBalanceDefinition>) {
        super('LoadBalanceDefinition');
        Object.assign(this, init);
    }
}

export class LogDefinition extends CamelElement {
    stepName?: string = 'log';
    id?: string = 'log-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    message: string = '';
    loggingLevel?: string;
    logName?: string;
    marker?: string;
    logger?: string;
    public constructor(init?: Partial<LogDefinition>) {
        super('LogDefinition');
        Object.assign(this, init);
    }
}

export class LoopDefinition extends CamelElement {
    stepName?: string = 'loop';
    id?: string = 'loop-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    copy?: boolean;
    doWhile?: boolean;
    breakOnShutdown?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<LoopDefinition>) {
        super('LoopDefinition');
        Object.assign(this, init);
    }
}

export class MarshalDefinition extends CamelElement {
    stepName?: string = 'marshal';
    id?: string = 'marshal-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    variableSend?: string;
    variableReceive?: string;
    asn1?: ASN1DataFormat | string;
    avro?: AvroDataFormat | string;
    barcode?: BarcodeDataFormat;
    base64?: Base64DataFormat;
    beanio?: BeanioDataFormat;
    bindy?: BindyDataFormat;
    cbor?: CBORDataFormat;
    crypto?: CryptoDataFormat;
    csv?: CsvDataFormat | string;
    custom?: CustomDataFormat | string;
    fhirJson?: FhirJsonDataFormat;
    fhirXml?: FhirXmlDataFormat;
    flatpack?: FlatpackDataFormat;
    grok?: GrokDataFormat;
    gzipDeflater?: GzipDeflaterDataFormat;
    hl7?: HL7DataFormat;
    ical?: IcalDataFormat;
    jacksonXml?: JacksonXMLDataFormat;
    jaxb?: JaxbDataFormat;
    json?: JsonDataFormat;
    jsonApi?: JsonApiDataFormat;
    lzf?: LZFDataFormat;
    mimeMultipart?: MimeMultipartDataFormat;
    parquetAvro?: ParquetAvroDataFormat | string;
    pgp?: PGPDataFormat;
    protobuf?: ProtobufDataFormat | string;
    rss?: RssDataFormat;
    soap?: SoapDataFormat | string;
    swiftMt?: SwiftMtDataFormat | string;
    swiftMx?: SwiftMxDataFormat;
    syslog?: SyslogDataFormat;
    tarFile?: TarFileDataFormat;
    thrift?: ThriftDataFormat | string;
    tidyMarkup?: TidyMarkupDataFormat;
    univocityCsv?: UniVocityCsvDataFormat;
    univocityFixed?: UniVocityFixedDataFormat;
    univocityTsv?: UniVocityTsvDataFormat;
    xmlSecurity?: XMLSecurityDataFormat;
    yaml?: YAMLDataFormat;
    zipDeflater?: ZipDeflaterDataFormat;
    zipFile?: ZipFileDataFormat;
    public constructor(init?: Partial<MarshalDefinition>) {
        super('MarshalDefinition');
        Object.assign(this, init);
    }
}

export class MulticastDefinition extends CamelElement {
    stepName?: string = 'multicast';
    id?: string = 'multicast-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    aggregationStrategy?: string;
    aggregationStrategyMethodName?: string;
    aggregationStrategyMethodAllowNull?: boolean;
    parallelAggregate?: boolean;
    parallelProcessing?: boolean;
    synchronous?: boolean;
    streaming?: boolean;
    stopOnException?: boolean;
    timeout?: string;
    executorService?: string;
    onPrepare?: string;
    shareUnitOfWork?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<MulticastDefinition>) {
        super('MulticastDefinition');
        Object.assign(this, init);
    }
}

export class OnCompletionDefinition extends CamelElement {
    stepName?: string = 'onCompletion';
    id?: string = 'onCompletion-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    mode?: string;
    onCompleteOnly?: boolean;
    onFailureOnly?: boolean;
    parallelProcessing?: boolean;
    executorService?: string;
    useOriginalMessage?: boolean;
    onWhen?: WhenDefinition;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<OnCompletionDefinition>) {
        super('OnCompletionDefinition');
        Object.assign(this, init);
    }
}

export class OnExceptionDefinition extends CamelElement {
    stepName?: string = 'onException';
    id?: string = 'onException-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    exception?: string[] = [];
    onWhen?: WhenDefinition;
    retryWhile?: ExpressionSubElementDefinition;
    redeliveryPolicy?: RedeliveryPolicyDefinition;
    redeliveryPolicyRef?: string;
    handled?: ExpressionSubElementDefinition;
    continued?: ExpressionSubElementDefinition;
    onRedeliveryRef?: string;
    onExceptionOccurredRef?: string;
    useOriginalMessage?: boolean;
    useOriginalBody?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<OnExceptionDefinition>) {
        super('OnExceptionDefinition');
        Object.assign(this, init);
    }
}

export class OnFallbackDefinition extends CamelElement {
    stepName?: string = 'onFallback';
    id?: string = 'onFallback-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    fallbackViaNetwork?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<OnFallbackDefinition>) {
        super('OnFallbackDefinition');
        Object.assign(this, init);
    }
}

export class OptimisticLockRetryPolicyDefinition extends CamelElement {
    stepName?: string = 'optimisticLockRetryPolicy';
    maximumRetries?: number;
    retryDelay?: string;
    maximumRetryDelay?: string;
    exponentialBackOff?: boolean;
    randomBackOff?: boolean;
    public constructor(init?: Partial<OptimisticLockRetryPolicyDefinition>) {
        super('OptimisticLockRetryPolicyDefinition');
        Object.assign(this, init);
    }
}

export class OtherwiseDefinition extends CamelElement {
    stepName?: string = 'otherwise';
    id?: string = 'otherwise-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<OtherwiseDefinition>) {
        super('OtherwiseDefinition');
        Object.assign(this, init);
    }
}

export class OutputDefinition extends CamelElement {
    stepName?: string = 'output';
    description?: string;
    disabled?: boolean;
    id?: string = 'output-' + uuidv4().substring(0,4);
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<OutputDefinition>) {
        super('OutputDefinition');
        Object.assign(this, init);
    }
}

export class OutputTypeDefinition extends CamelElement {
    stepName?: string = 'outputType';
    id?: string = 'outputType-' + uuidv4().substring(0,4);
    description?: string;
    urn: string = '';
    validate?: boolean;
    public constructor(init?: Partial<OutputTypeDefinition>) {
        super('OutputTypeDefinition');
        Object.assign(this, init);
    }
}

export class PackageScanDefinition extends CamelElement {
    stepName?: string = 'packageScan';
    package?: string[] = [];
    excludes?: string[] = [];
    includes?: string[] = [];
    public constructor(init?: Partial<PackageScanDefinition>) {
        super('PackageScanDefinition');
        Object.assign(this, init);
    }
}

export class PausableDefinition extends CamelElement {
    stepName?: string = 'pausable';
    id?: string = 'pausable-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    consumerListener: string = '';
    untilCheck: string = '';
    public constructor(init?: Partial<PausableDefinition>) {
        super('PausableDefinition');
        Object.assign(this, init);
    }
}

export class PipelineDefinition extends CamelElement {
    stepName?: string = 'pipeline';
    id?: string = 'pipeline-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<PipelineDefinition>) {
        super('PipelineDefinition');
        Object.assign(this, init);
    }
}

export class PolicyDefinition extends CamelElement {
    stepName?: string = 'policy';
    id?: string = 'policy-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    ref: string = '';
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<PolicyDefinition>) {
        super('PolicyDefinition');
        Object.assign(this, init);
    }
}

export class PollDefinition extends CamelElement {
    stepName?: string = 'poll';
    id?: string = 'poll-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    variableReceive?: string;
    uri: string = '';
    timeout?: string;
    parameters?: any = {};
    public constructor(init?: Partial<PollDefinition>) {
        super('PollDefinition');
        Object.assign(this, init);
    }
}

export class PollEnrichDefinition extends CamelElement {
    stepName?: string = 'pollEnrich';
    id?: string = 'pollEnrich-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    variableReceive?: string;
    aggregationStrategy?: string;
    aggregationStrategyMethodName?: string;
    aggregationStrategyMethodAllowNull?: string;
    aggregateOnException?: boolean;
    timeout?: string;
    cacheSize?: number;
    ignoreInvalidEndpoint?: boolean;
    autoStartComponents?: boolean;
    public constructor(init?: Partial<PollEnrichDefinition>) {
        super('PollEnrichDefinition');
        Object.assign(this, init);
    }
}

export class ProcessDefinition extends CamelElement {
    stepName?: string = 'process';
    id?: string = 'process-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    ref: string = '';
    public constructor(init?: Partial<ProcessDefinition>) {
        super('ProcessDefinition');
        Object.assign(this, init);
    }
}

export class PropertyDefinition extends CamelElement {
    stepName?: string = 'property';
    key: string = '';
    value: string = '';
    public constructor(init?: Partial<PropertyDefinition>) {
        super('PropertyDefinition');
        Object.assign(this, init);
    }
}

export class PropertyExpressionDefinition extends CamelElement {
    stepName?: string = 'propertyExpression';
    key: string = '';
    expression?: ExpressionDefinition;
    public constructor(init?: Partial<PropertyExpressionDefinition>) {
        super('PropertyExpressionDefinition');
        Object.assign(this, init);
    }
}

export class RecipientListDefinition extends CamelElement {
    stepName?: string = 'recipientList';
    id?: string = 'recipientList-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    delimiter?: string;
    aggregationStrategy?: string;
    aggregationStrategyMethodName?: string;
    aggregationStrategyMethodAllowNull?: boolean;
    parallelAggregate?: boolean;
    parallelProcessing?: boolean;
    synchronous?: boolean;
    timeout?: string;
    executorService?: string;
    stopOnException?: boolean;
    ignoreInvalidEndpoints?: boolean;
    streaming?: boolean;
    onPrepare?: string;
    cacheSize?: number;
    shareUnitOfWork?: boolean;
    public constructor(init?: Partial<RecipientListDefinition>) {
        super('RecipientListDefinition');
        Object.assign(this, init);
    }
}

export class RedeliveryPolicyDefinition extends CamelElement {
    stepName?: string = 'redeliveryPolicy';
    id?: string = 'redeliveryPolicy-' + uuidv4().substring(0,4);
    maximumRedeliveries?: number;
    redeliveryDelay?: string;
    asyncDelayedRedelivery?: boolean;
    backOffMultiplier?: number;
    useExponentialBackOff?: boolean;
    collisionAvoidanceFactor?: number;
    useCollisionAvoidance?: boolean;
    maximumRedeliveryDelay?: string;
    retriesExhaustedLogLevel?: string;
    retryAttemptedLogLevel?: string;
    retryAttemptedLogInterval?: number;
    logRetryAttempted?: boolean;
    logStackTrace?: boolean;
    logRetryStackTrace?: boolean;
    logHandled?: boolean;
    logNewException?: boolean;
    logContinued?: boolean;
    logExhausted?: boolean;
    logExhaustedMessageHistory?: boolean;
    logExhaustedMessageBody?: boolean;
    disableRedelivery?: boolean;
    delayPattern?: string;
    allowRedeliveryWhileStopping?: boolean;
    exchangeFormatterRef?: string;
    public constructor(init?: Partial<RedeliveryPolicyDefinition>) {
        super('RedeliveryPolicyDefinition');
        Object.assign(this, init);
    }
}

export class RemoveHeaderDefinition extends CamelElement {
    stepName?: string = 'removeHeader';
    id?: string = 'removeHeader-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    public constructor(init?: Partial<RemoveHeaderDefinition>) {
        super('RemoveHeaderDefinition');
        Object.assign(this, init);
    }
}

export class RemoveHeadersDefinition extends CamelElement {
    stepName?: string = 'removeHeaders';
    id?: string = 'removeHeaders-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    pattern: string = '';
    excludePattern?: string;
    public constructor(init?: Partial<RemoveHeadersDefinition>) {
        super('RemoveHeadersDefinition');
        Object.assign(this, init);
    }
}

export class RemovePropertiesDefinition extends CamelElement {
    stepName?: string = 'removeProperties';
    id?: string = 'removeProperties-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    pattern: string = '';
    excludePattern?: string;
    public constructor(init?: Partial<RemovePropertiesDefinition>) {
        super('RemovePropertiesDefinition');
        Object.assign(this, init);
    }
}

export class RemovePropertyDefinition extends CamelElement {
    stepName?: string = 'removeProperty';
    id?: string = 'removeProperty-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    public constructor(init?: Partial<RemovePropertyDefinition>) {
        super('RemovePropertyDefinition');
        Object.assign(this, init);
    }
}

export class RemoveVariableDefinition extends CamelElement {
    stepName?: string = 'removeVariable';
    id?: string = 'removeVariable-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    public constructor(init?: Partial<RemoveVariableDefinition>) {
        super('RemoveVariableDefinition');
        Object.assign(this, init);
    }
}

export class ResequenceDefinition extends CamelElement {
    stepName?: string = 'resequence';
    id?: string = 'resequence-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    batchConfig?: BatchResequencerConfig;
    streamConfig?: StreamResequencerConfig;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<ResequenceDefinition>) {
        super('ResequenceDefinition');
        Object.assign(this, init);
    }
}

export class Resilience4jConfigurationDefinition extends CamelElement {
    stepName?: string = 'resilience4jConfiguration';
    id?: string = 'resilience4jConfiguration-' + uuidv4().substring(0,4);
    circuitBreaker?: string;
    config?: string;
    failureRateThreshold?: number;
    permittedNumberOfCallsInHalfOpenState?: number;
    throwExceptionWhenHalfOpenOrOpenState?: boolean;
    slidingWindowSize?: number;
    slidingWindowType?: string;
    minimumNumberOfCalls?: number;
    writableStackTraceEnabled?: boolean;
    waitDurationInOpenState?: number;
    automaticTransitionFromOpenToHalfOpenEnabled?: boolean;
    slowCallRateThreshold?: number;
    slowCallDurationThreshold?: number;
    bulkheadEnabled?: boolean;
    bulkheadMaxConcurrentCalls?: number;
    bulkheadMaxWaitDuration?: number;
    timeoutEnabled?: boolean;
    timeoutExecutorService?: string;
    timeoutDuration?: number;
    timeoutCancelRunningFuture?: boolean;
    recordException?: string[] = [];
    ignoreException?: string[] = [];
    public constructor(init?: Partial<Resilience4jConfigurationDefinition>) {
        super('Resilience4jConfigurationDefinition');
        Object.assign(this, init);
    }
}

export class RestContextRefDefinition extends CamelElement {
    stepName?: string = 'restContextRef';
    ref: string = '';
    public constructor(init?: Partial<RestContextRefDefinition>) {
        super('RestContextRefDefinition');
        Object.assign(this, init);
    }
}

export class ResumableDefinition extends CamelElement {
    stepName?: string = 'resumable';
    id?: string = 'resumable-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    resumeStrategy: string = '';
    loggingLevel?: string;
    intermittent?: boolean;
    public constructor(init?: Partial<ResumableDefinition>) {
        super('ResumableDefinition');
        Object.assign(this, init);
    }
}

export class RollbackDefinition extends CamelElement {
    stepName?: string = 'rollback';
    id?: string = 'rollback-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    message?: string;
    markRollbackOnly?: boolean;
    markRollbackOnlyLast?: boolean;
    public constructor(init?: Partial<RollbackDefinition>) {
        super('RollbackDefinition');
        Object.assign(this, init);
    }
}

export class RouteBuilderDefinition extends CamelElement {
    stepName?: string = 'routeBuilder';
    id?: string = 'routeBuilder-' + uuidv4().substring(0,4);
    ref: string = '';
    public constructor(init?: Partial<RouteBuilderDefinition>) {
        super('RouteBuilderDefinition');
        Object.assign(this, init);
    }
}

export class RouteConfigurationContextRefDefinition extends CamelElement {
    stepName?: string = 'routeConfigurationContextRef';
    ref: string = '';
    public constructor(init?: Partial<RouteConfigurationContextRefDefinition>) {
        super('RouteConfigurationContextRefDefinition');
        Object.assign(this, init);
    }
}

export class RouteConfigurationDefinition extends CamelElement {
    stepName?: string = 'routeConfiguration';
    id?: string;
    description?: string;
    errorHandler?: ErrorHandlerDefinition;
    intercept?: InterceptDefinition[] = [];
    interceptFrom?: InterceptFromDefinition[] = [];
    interceptSendToEndpoint?: InterceptSendToEndpointDefinition[] = [];
    onException?: OnExceptionDefinition[] = [];
    onCompletion?: OnCompletionDefinition[] = [];
    precondition?: string;
    public constructor(init?: Partial<RouteConfigurationDefinition>) {
        super('RouteConfigurationDefinition');
        Object.assign(this, init);
    }
}

export class RouteContextRefDefinition extends CamelElement {
    stepName?: string = 'routeContextRef';
    ref: string = '';
    public constructor(init?: Partial<RouteContextRefDefinition>) {
        super('RouteContextRefDefinition');
        Object.assign(this, init);
    }
}

export class RouteDefinition extends CamelElement {
    stepName?: string = 'route';
    id?: string = 'route-' + uuidv4().substring(0,4);
    description?: string;
    group?: string;
    nodePrefixId?: string;
    routeConfigurationId?: string;
    autoStartup?: boolean;
    startupOrder?: number;
    streamCache?: boolean;
    trace?: boolean;
    messageHistory?: boolean;
    logMask?: boolean;
    errorHandlerRef?: string;
    shutdownRoute?: string;
    shutdownRunningTask?: string;
    precondition?: string;
    errorHandler?: ErrorHandlerDefinition;
    inputType?: InputTypeDefinition;
    outputType?: OutputTypeDefinition;
    from: FromDefinition = new FromDefinition();
    public constructor(init?: Partial<RouteDefinition>) {
        super('RouteDefinition');
        Object.assign(this, init);
    }
}

export class RouteTemplateDefinition extends CamelElement {
    stepName?: string = 'routeTemplate';
    id: string = 'routeTemplate-' + uuidv4().substring(0,4);
    description?: string;
    route?: RouteDefinition;
    beans?: BeanFactoryDefinition[] = [];
    from?: FromDefinition;
    parameters?: RouteTemplateParameterDefinition[] = [];
    public constructor(init?: Partial<RouteTemplateDefinition>) {
        super('RouteTemplateDefinition');
        Object.assign(this, init);
    }
}

export class RouteTemplateParameterDefinition extends CamelElement {
    stepName?: string = 'routeTemplateParameter';
    defaultValue?: string;
    description?: string;
    name: string = '';
    required?: boolean;
    public constructor(init?: Partial<RouteTemplateParameterDefinition>) {
        super('RouteTemplateParameterDefinition');
        Object.assign(this, init);
    }
}

export class RoutingSlipDefinition extends CamelElement {
    stepName?: string = 'routingSlip';
    id?: string = 'routingSlip-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    uriDelimiter?: string;
    ignoreInvalidEndpoints?: boolean;
    cacheSize?: number;
    public constructor(init?: Partial<RoutingSlipDefinition>) {
        super('RoutingSlipDefinition');
        Object.assign(this, init);
    }
}

export class SagaActionUriDefinition extends CamelElement {
    stepName?: string = 'sagaActionUri';
    description?: string;
    disabled?: boolean;
    id?: string = 'sagaActionUri-' + uuidv4().substring(0,4);
    parameters?: any = {};
    uri: string = '';
    public constructor(init?: Partial<SagaActionUriDefinition>) {
        super('SagaActionUriDefinition');
        Object.assign(this, init);
    }
}

export class SagaDefinition extends CamelElement {
    stepName?: string = 'saga';
    id?: string = 'saga-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    sagaService?: string;
    propagation?: string;
    completionMode?: string;
    timeout?: string;
    compensation?: string;
    completion?: string;
    option?: PropertyExpressionDefinition[] = [];
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<SagaDefinition>) {
        super('SagaDefinition');
        Object.assign(this, init);
    }
}

export class SamplingDefinition extends CamelElement {
    stepName?: string = 'sample';
    id?: string = 'sample-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    samplePeriod?: string;
    messageFrequency?: number;
    public constructor(init?: Partial<SamplingDefinition>) {
        super('SamplingDefinition');
        Object.assign(this, init);
    }
}

export class ScriptDefinition extends CamelElement {
    stepName?: string = 'script';
    id?: string = 'script-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    public constructor(init?: Partial<ScriptDefinition>) {
        super('ScriptDefinition');
        Object.assign(this, init);
    }
}

export class SetBodyDefinition extends CamelElement {
    stepName?: string = 'setBody';
    id?: string = 'setBody-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    public constructor(init?: Partial<SetBodyDefinition>) {
        super('SetBodyDefinition');
        Object.assign(this, init);
    }
}

export class SetExchangePatternDefinition extends CamelElement {
    stepName?: string = 'setExchangePattern';
    id?: string = 'setExchangePattern-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    pattern?: string;
    public constructor(init?: Partial<SetExchangePatternDefinition>) {
        super('SetExchangePatternDefinition');
        Object.assign(this, init);
    }
}

export class SetHeaderDefinition extends CamelElement {
    stepName?: string = 'setHeader';
    id?: string = 'setHeader-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    expression?: ExpressionDefinition;
    public constructor(init?: Partial<SetHeaderDefinition>) {
        super('SetHeaderDefinition');
        Object.assign(this, init);
    }
}

export class SetHeadersDefinition extends CamelElement {
    stepName?: string = 'setHeaders';
    id?: string = 'setHeaders-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    headers?: SetHeaderDefinition[] = [];
    public constructor(init?: Partial<SetHeadersDefinition>) {
        super('SetHeadersDefinition');
        Object.assign(this, init);
    }
}

export class SetPropertyDefinition extends CamelElement {
    stepName?: string = 'setProperty';
    id?: string = 'setProperty-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    expression?: ExpressionDefinition;
    public constructor(init?: Partial<SetPropertyDefinition>) {
        super('SetPropertyDefinition');
        Object.assign(this, init);
    }
}

export class SetVariableDefinition extends CamelElement {
    stepName?: string = 'setVariable';
    id?: string = 'setVariable-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    name: string = '';
    expression?: ExpressionDefinition;
    public constructor(init?: Partial<SetVariableDefinition>) {
        super('SetVariableDefinition');
        Object.assign(this, init);
    }
}

export class SetVariablesDefinition extends CamelElement {
    stepName?: string = 'setVariables';
    id?: string = 'setVariables-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    variables?: SetVariableDefinition[] = [];
    public constructor(init?: Partial<SetVariablesDefinition>) {
        super('SetVariablesDefinition');
        Object.assign(this, init);
    }
}

export class SortDefinition extends CamelElement {
    stepName?: string = 'sort';
    id?: string = 'sort-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    comparator?: string;
    public constructor(init?: Partial<SortDefinition>) {
        super('SortDefinition');
        Object.assign(this, init);
    }
}

export class SplitDefinition extends CamelElement {
    stepName?: string = 'split';
    id?: string = 'split-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    expression?: ExpressionDefinition;
    delimiter?: string;
    aggregationStrategy?: string;
    aggregationStrategyMethodName?: string;
    aggregationStrategyMethodAllowNull?: boolean;
    parallelAggregate?: boolean;
    parallelProcessing?: boolean;
    synchronous?: boolean;
    streaming?: boolean;
    stopOnException?: boolean;
    timeout?: string;
    executorService?: string;
    onPrepare?: string;
    shareUnitOfWork?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<SplitDefinition>) {
        super('SplitDefinition');
        Object.assign(this, init);
    }
}

export class StepDefinition extends CamelElement {
    stepName?: string = 'step';
    id?: string = 'step-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    steps?: CamelElement[] = [];
    public constructor(init?: Partial<StepDefinition>) {
        super('StepDefinition');
        Object.assign(this, init);
    }
}

export class StopDefinition extends CamelElement {
    stepName?: string = 'stop';
    id?: string = 'stop-' + uuidv4().substring(0,4);
    description?: string;
    disabled?: boolean;
    public constructor(init?: Partial<StopDefinition>) {
        super('StopDefinition');
        Object.assign(this, init);
    }
}

export class TemplatedRouteDefinition extends CamelElement {
    stepName?: string = 'templatedRoute';
    routeTemplateRef: string = '';
    routeId?: string;
    prefixId?: string;
    beans?: BeanFactoryDefinition[] = [];
    parameters?: TemplatedRouteParameterDefinition[] = [];
    public constructor(init?: Partial<TemplatedRouteDefinition>) {
        super('TemplatedRouteDefinition');
        Object.assign(this, init);
    }
}

export class TemplatedRouteParameterDefinition extends CamelElement {
    stepName?: string = 'templatedRouteParameter';
    name: string = '';
    value: string = '';
    public constructor(init?: Partial<TemplatedRouteParameterDefinition>) {
        super('TemplatedRouteParameterDefinition');
        Object.assign(this, init);
    }
}

export class ThreadPoolProfileDefinition extends CamelElement {
    stepName?: string = 'threadPoolProfile';
    id?: string = 'threadPoolProfile-' + uuidv4().substring(0,4);
    description?: string;
    defaultProfile?: boolean;
    poolSize?: number;
    maxPoolSize?: number;
    keepAliveTime?: nu