/**
 * Generated by karavan build tools - do NOT edit this file!
 */
import {CamelElement} from "./IntegrationDefinition";
export class ProcessorDefinition extends CamelElement {
    idempotentConsumer?: IdempotentConsumerDefinition;
    resumable?: ResumableDefinition;
    doTry?: TryDefinition;
    convertBodyTo?: ConvertBodyDefinition | string;
    recipientList?: RecipientListDefinition;
    when?: WhenDefinition;
    setHeader?: SetHeaderDefinition;
    inOnly?: InOnlyDefinition | string;
    inOut?: InOutDefinition | string;
    split?: SplitDefinition;
    interceptSendToEndpoint?: InterceptSendToEndpointDefinition | string;
    loop?: LoopDefinition;
    setExchangePattern?: SetExchangePatternDefinition | string;
    marshal?: MarshalDefinition;
    onFallback?: OnFallbackDefinition;
    circuitBreaker?: CircuitBreakerDefinition;
    enrich?: EnrichDefinition;
    kamelet?: KameletDefinition | string;
    saga?: SagaDefinition;
    bean?: BeanDefinition | string;
    otherwise?: OtherwiseDefinition;
    toD?: string;
    sort?: SortDefinition;
    loadBalance?: LoadBalanceDefinition;
    script?: ScriptDefinition;
    removeHeader?: RemoveHeaderDefinition | string;
    delay?: DelayDefinition;
    stop?: StopDefinition;
    serviceCall?: ServiceCallDefinition | string;
    intercept?: InterceptDefinition;
    whenSkipSendToEndpoint?: WhenSkipSendToEndpointDefinition;
    setProperty?: SetPropertyDefinition;
    removeProperty?: RemovePropertyDefinition | string;
    interceptFrom?: InterceptFromDefinition | string;
    onCompletion?: OnCompletionDefinition;
    pausable?: PausableDefinition;
    throttle?: ThrottleDefinition;
    doFinally?: FinallyDefinition;
    log?: LogDefinition | string;
    doCatch?: CatchDefinition;
    transacted?: TransactedDefinition;
    claimCheck?: ClaimCheckDefinition;
    pollEnrich?: PollEnrichDefinition;
    removeHeaders?: RemoveHeadersDefinition | string;
    aggregate?: AggregateDefinition;
    resequence?: ResequenceDefinition;
    routingSlip?: RoutingSlipDefinition | string;
    transform?: TransformDefinition;
    stepName?: string = 'processor';
    removeProperties?: RemovePropertiesDefinition | string;
    policy?: PolicyDefinition;
    validate?: ValidateDefinition;
    rollback?: RollbackDefinition | string;
    process?: ProcessDefinition;
    threads?: ThreadsDefinition;
    setBody?: SetBodyDefinition;
    sample?: SamplingDefinition | string;
    throwException?: ThrowExceptionDefinition;
    dynamicRouter?: DynamicRouterDefinition;
    multicast?: MulticastDefinition;
    filter?: FilterDefinition;
    pipeline?: PipelineDefinition;
    unmarshal?: UnmarshalDefinition;
    wireTap?: WireTapDefinition;
    step?: StepDefinition;
    to?: string;
    choice?: ChoiceDefinition
    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 ErrorHandlerBuilderDeserializer extends CamelElement {
    deadLetterChannel?: DeadLetterChannelDefinition;
    ref?: string;
    log?: DefaultErrorHandlerDefinition;
    none?: NoErrorHandlerDefinition
    public constructor(init?: Partial<ErrorHandlerBuilderDeserializer>) {
        super('ErrorHandlerBuilderDeserializer')
        Object.assign(this, init)
    }
}

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

export class OutputAwareFromDefinition extends CamelElement {
    description?: string;
    id?: string;
    parameters?: any = {};
    steps: CamelElement[] = [];
    uri: string = ''
    public constructor(init?: Partial<OutputAwareFromDefinition>) {
        super('OutputAwareFromDefinition')
        Object.assign(this, init)
    }
}

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

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

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

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

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

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

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

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

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

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

export class DescriptionDefinition extends CamelElement {
    stepName?: string = 'description';
    text?: string;
    lang?: string
    public constructor(init?: Partial<DescriptionDefinition>) {
        super('DescriptionDefinition')
        Object.assign(this, init)
    }
}

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

export class EnrichDefinition extends CamelElement {
    aggregationStrategy?: string;
    cacheSize?: number;
    expression?: ExpressionDefinition;
    description?: string;
    allowOptimisedComponents?: boolean;
    aggregationStrategyMethodName?: string;
    inheritErrorHandler?: boolean;
    stepName?: string = 'enrich';
    ignoreInvalidEndpoint?: boolean;
    id?: string;
    aggregateOnException?: boolean;
    aggregationStrategyMethodAllowNull?: string;
    shareUnitOfWork?: boolean
    public constructor(init?: Partial<EnrichDefinition>) {
        super('EnrichDefinition')
        Object.assign(this, init)
    }
}

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

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

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

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

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

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

export class GlobalOptionDefinition extends CamelElement {
    stepName?: string = 'globalOption';
    value: string = '';
    key: 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 {
    completionEager?: boolean;
    skipDuplicate?: boolean;
    inheritErrorHandler?: boolean;
    expression?: ExpressionDefinition;
    eager?: boolean;
    stepName?: string = 'idempotentConsumer';
    idempotentRepository: string = '';
    description?: string;
    removeOnFailure?: boolean;
    id?: string;
    steps?: CamelElement[] = []
    public constructor(init?: Partial<IdempotentConsumerDefinition>) {
        super('IdempotentConsumerDefinition')
        Object.assign(this, init)
    }
}

export class InOnlyDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    stepName?: string = 'inOnly';
    description?: string;
    id?: string;
    parameters?: any = {};
    uri: string = ''
    public constructor(init?: Partial<InOnlyDefinition>) {
        super('InOnlyDefinition')
        Object.assign(this, init)
    }
}

export class InOutDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    stepName?: string = 'inOut';
    description?: string;
    id?: string;
    parameters?: any = {};
    uri: string = ''
    public constructor(init?: Partial<InOutDefinition>) {
        super('InOutDefinition')
        Object.assign(this, init)
    }
}

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

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

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

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

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

export class LoadBalanceDefinition extends CamelElement {
    random?: RandomLoadBalancerDefinition;
    inheritErrorHandler?: boolean;
    customLoadBalancer?: CustomLoadBalancerDefinition | string;
    stepName?: string = 'loadBalance';
    failover?: FailoverLoadBalancerDefinition;
    sticky?: StickyLoadBalancerDefinition;
    description?: string;
    topic?: TopicLoadBalancerDefinition;
    id?: string;
    steps?: CamelElement[] = [];
    weighted?: WeightedLoadBalancerDefinition;
    roundRobin?: RoundRobinLoadBalancerDefinition
    public constructor(init?: Partial<LoadBalanceDefinition>) {
        super('LoadBalanceDefinition')
        Object.assign(this, init)
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export class Resilience4jConfigurationDefinition extends CamelElement {
    failureRateThreshold?: number;
    slowCallDurationThreshold?: number;
    minimumNumberOfCalls?: number;
    permittedNumberOfCallsInHalfOpenState?: number;
    slowCallRateThreshold?: number;
    stepName?: string = 'resilience4jConfiguration';
    writableStackTraceEnabled?: boolean;
    automaticTransitionFromOpenToHalfOpenEnabled?: boolean;
    circuitBreaker?: string;
    slidingWindowSize?: number;
    id?: string;
    config?: string;
    slidingWindowType?: string;
    waitDurationInOpenState?: number
    public constructor(init?: Partial<Resilience4jConfigurationDefinition>) {
        super('Resilience4jConfigurationDefinition')
        Object.assign(this, init)
    }
}

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

export class ResumableDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    stepName?: string = 'resumable';
    resumeStrategy: string = '';
    intermittent?: boolean;
    description?: string;
    id?: string
    public constructor(init?: Partial<ResumableDefinition>) {
        super('ResumableDefinition')
        Object.assign(this, init)
    }
}

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

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

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

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

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

export class RouteDefinition extends CamelElement {
    routeConfigurationId?: string;
    description?: string;
    logMask?: boolean;
    precondition?: string;
    autoStartup?: boolean;
    trace?: boolean;
    stepName?: string = 'route';
    messageHistory?: boolean;
    from: FromDefinition = new FromDefinition();
    streamCaching?: boolean;
    id?: string;
    startupOrder?: number;
    routePolicy?: string;
    group?: string
    public constructor(init?: Partial<RouteDefinition>) {
        super('RouteDefinition')
        Object.assign(this, init)
    }
}

export class RouteTemplateBeanDefinition extends CamelElement {
    stepName?: string = 'routeTemplateBean';
    name: string = '';
    property?: PropertyDefinition[] = [];
    type: string = '';
    beanType?: string;
    properties?: any = {};
    script?: string
    public constructor(init?: Partial<RouteTemplateBeanDefinition>) {
        super('RouteTemplateBeanDefinition')
        Object.assign(this, init)
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export class TemplatedRouteBeanDefinition extends CamelElement {
    stepName?: string = 'templatedRouteBean';
    name: string = '';
    property?: PropertyDefinition[] = [];
    type: string = '';
    beanType?: string;
    properties?: any = {};
    script?: string
    public constructor(init?: Partial<TemplatedRouteBeanDefinition>) {
        super('TemplatedRouteBeanDefinition')
        Object.assign(this, init)
    }
}

export class TemplatedRouteDefinition extends CamelElement {
    routeId?: string;
    stepName?: string = 'templatedRoute';
    beans?: NamedBeanDefinition[] = [];
    parameters?: TemplatedRouteParameterDefinition[] = [];
    routeTemplateRef: string = ''
    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 {
    keepAliveTime?: number;
    stepName?: string = 'threadPoolProfile';
    maxQueueSize?: number;
    allowCoreThreadTimeOut?: boolean;
    poolSize?: number;
    description?: string;
    defaultProfile?: boolean;
    id?: string;
    maxPoolSize?: number;
    rejectedPolicy?: string;
    timeUnit?: string
    public constructor(init?: Partial<ThreadPoolProfileDefinition>) {
        super('ThreadPoolProfileDefinition')
        Object.assign(this, init)
    }
}

export class ThreadsDefinition extends CamelElement {
    keepAliveTime?: number;
    callerRunsWhenRejected?: string;
    executorService?: string;
    poolSize?: number;
    description?: string;
    threadName?: string;
    rejectedPolicy?: string;
    inheritErrorHandler?: boolean;
    stepName?: string = 'threads';
    maxQueueSize?: number;
    allowCoreThreadTimeOut?: boolean;
    id?: string;
    maxPoolSize?: number;
    timeUnit?: string
    public constructor(init?: Partial<ThreadsDefinition>) {
        super('ThreadsDefinition')
        Object.assign(this, init)
    }
}

export class ThrottleDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    expression?: ExpressionDefinition;
    stepName?: string = 'throttle';
    callerRunsWhenRejected?: boolean;
    executorService?: string;
    timePeriodMillis?: string;
    asyncDelayed?: boolean;
    description?: string;
    rejectExecution?: boolean;
    correlationExpression?: ExpressionSubElementDefinition;
    id?: string
    public constructor(init?: Partial<ThrottleDefinition>) {
        super('ThrottleDefinition')
        Object.assign(this, init)
    }
}

export class ThrowExceptionDefinition extends CamelElement {
    exceptionType?: string;
    inheritErrorHandler?: boolean;
    ref?: string;
    stepName?: string = 'throwException';
    description?: string;
    id?: string;
    message?: string
    public constructor(init?: Partial<ThrowExceptionDefinition>) {
        super('ThrowExceptionDefinition')
        Object.assign(this, init)
    }
}

export class ToDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    stepName?: string = 'to';
    pattern?: string;
    description?: string;
    id?: string;
    parameters?: any = {};
    uri: string = ''
    public constructor(init?: Partial<ToDefinition>) {
        super('ToDefinition')
        Object.assign(this, init)
    }
}

export class ToDynamicDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    cacheSize?: number;
    stepName?: string = 'toD';
    ignoreInvalidEndpoint?: boolean;
    autoStartComponents?: boolean;
    pattern?: string;
    description?: string;
    id?: string;
    allowOptimisedComponents?: boolean;
    parameters?: any = {};
    uri: string = ''
    public constructor(init?: Partial<ToDynamicDefinition>) {
        super('ToDynamicDefinition')
        Object.assign(this, init)
    }
}

export class TransactedDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    ref?: string;
    stepName?: string = 'transacted';
    description?: string;
    id?: string;
    steps?: CamelElement[] = []
    public constructor(init?: Partial<TransactedDefinition>) {
        super('TransactedDefinition')
        Object.assign(this, init)
    }
}

export class TransformDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    expression?: ExpressionDefinition;
    stepName?: string = 'transform';
    description?: string;
    id?: string
    public constructor(init?: Partial<TransformDefinition>) {
        super('TransformDefinition')
        Object.assign(this, init)
    }
}

export class TryDefinition extends CamelElement {
    doFinally?: FinallyDefinition;
    inheritErrorHandler?: boolean;
    stepName?: string = 'doTry';
    doCatch?: CatchDefinition[] = [];
    description?: string;
    id?: string;
    steps?: CamelElement[] = []
    public constructor(init?: Partial<TryDefinition>) {
        super('TryDefinition')
        Object.assign(this, init)
    }
}

export class UnmarshalDefinition extends CamelElement {
    univocityCsv?: UniVocityCsvDataFormat;
    protobuf?: ProtobufDataFormat | string;
    tarFile?: TarFileDataFormat;
    tidyMarkup?: TidyMarkupDataFormat;
    csv?: CsvDataFormat | string;
    base64?: Base64DataFormat;
    zipDeflater?: ZipDeflaterDataFormat;
    description?: string;
    bindy?: BindyDataFormat;
    syslog?: SyslogDataFormat;
    zipFile?: ZipFileDataFormat;
    jaxb?: JaxbDataFormat;
    rss?: RssDataFormat;
    stepName?: string = 'unmarshal';
    mimeMultipart?: MimeMultipartDataFormat;
    asn1?: ASN1DataFormat | string;
    pgp?: PGPDataFormat;
    thrift?: ThriftDataFormat | string;
    json?: JsonDataFormat;
    lzf?: LZFDataFormat;
    id?: string;
    fhirXml?: FhirXmlDataFormat;
    barcode?: BarcodeDataFormat;
    allowNullBody?: boolean;
    avro?: AvroDataFormat | string;
    yaml?: YAMLDataFormat;
    fhirJson?: FhirJsonDataFormat;
    any23?: Any23DataFormat | string;
    custom?: CustomDataFormat | string;
    flatpack?: FlatpackDataFormat;
    cbor?: CBORDataFormat;
    crypto?: CryptoDataFormat;
    univocityTsv?: UniVocityTsvDataFormat;
    hl7?: HL7DataFormat;
    inheritErrorHandler?: boolean;
    jsonApi?: JsonApiDataFormat;
    xmlSecurity?: XMLSecurityDataFormat;
    ical?: IcalDataFormat;
    univocityFixed?: UniVocityFixedDataFormat;
    jacksonXml?: JacksonXMLDataFormat;
    grok?: GrokDataFormat;
    xstream?: XStreamDataFormat | string;
    gzipDeflater?: GzipDeflaterDataFormat;
    soap?: SoapDataFormat | string
    public constructor(init?: Partial<UnmarshalDefinition>) {
        super('UnmarshalDefinition')
        Object.assign(this, init)
    }
}

export class ValidateDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    expression?: ExpressionDefinition;
    stepName?: string = 'validate';
    description?: string;
    id?: string;
    predicateExceptionFactory?: string
    public constructor(init?: Partial<ValidateDefinition>) {
        super('ValidateDefinition')
        Object.assign(this, init)
    }
}

export class WhenDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    expression?: ExpressionDefinition;
    stepName?: string = 'when';
    description?: string;
    id?: string;
    steps?: CamelElement[] = []
    public constructor(init?: Partial<WhenDefinition>) {
        super('WhenDefinition')
        Object.assign(this, init)
    }
}

export class WhenSkipSendToEndpointDefinition extends CamelElement {
    inheritErrorHandler?: boolean;
    expression?: ExpressionDefinition;
    stepName?: string = 'whenSkipSendToEndpoint';
    description?: string;
    id?: string;
    steps?: CamelElement[] = []
    public constructor(init?: Partial<WhenSkipSendToEndpointDefinition>) {
        super('WhenSkipSendToEndpointDefinition')
        Object.assign(this, init)
    }
}

export class WireTapDefinition extends CamelElement {
    cacheSize?: number;
    onPrepare?: string;
    executorService?: string;
    pattern?: string;
    description?: string;
    allowOptimisedComponents?: boolean;
    uri: string = '';
    dynamicUri?: boolean;
    inheritErrorHandler?: boolean;
    stepName?: string = 'wireTap';
    ignoreInvalidEndpoint?: boolean;
    autoStartComponents?: boolean;
    copy?: boolean;
    id?: string;
    parameters?: any = {}
    public constructor(init?: Partial<WireTapDefinition>) {
        super('WireTapDefinition')
        Object.assign(this, init)
    }
}

export class BlacklistServiceCallServiceFilterConfiguration extends CamelElement {
    servers?: string[] = [];
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<BlacklistServiceCallServiceFilterConfiguration>) {
        super('BlacklistServiceCallServiceFilterConfiguration')
        Object.assign(this, init)
    }
}

export class CachingServiceCallServiceDiscoveryConfiguration extends CamelElement {
    dnsServiceDiscovery?: DnsServiceCallServiceDiscoveryConfiguration;
    kubernetesServiceDiscovery?: KubernetesServiceCallServiceDiscoveryConfiguration;
    consulServiceDiscovery?: ConsulServiceCallServiceDiscoveryConfiguration;
    id?: string;
    units?: string;
    staticServiceDiscovery?: StaticServiceCallServiceDiscoveryConfiguration;
    combinedServiceDiscovery?: CombinedServiceCallServiceDiscoveryConfiguration;
    properties?: PropertyDefinition[] = [];
    timeout?: number
    public constructor(init?: Partial<CachingServiceCallServiceDiscoveryConfiguration>) {
        super('CachingServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class CombinedServiceCallServiceDiscoveryConfiguration extends CamelElement {
    cachingServiceDiscovery?: CachingServiceCallServiceDiscoveryConfiguration;
    dnsServiceDiscovery?: DnsServiceCallServiceDiscoveryConfiguration;
    kubernetesServiceDiscovery?: KubernetesServiceCallServiceDiscoveryConfiguration;
    consulServiceDiscovery?: ConsulServiceCallServiceDiscoveryConfiguration;
    id?: string;
    staticServiceDiscovery?: StaticServiceCallServiceDiscoveryConfiguration;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<CombinedServiceCallServiceDiscoveryConfiguration>) {
        super('CombinedServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class CombinedServiceCallServiceFilterConfiguration extends CamelElement {
    blacklistServiceFilter?: BlacklistServiceCallServiceFilterConfiguration;
    passThroughServiceFilter?: PassThroughServiceCallServiceFilterConfiguration;
    healthyServiceFilter?: HealthyServiceCallServiceFilterConfiguration;
    customServiceFilter?: CustomServiceCallServiceFilterConfiguration;
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<CombinedServiceCallServiceFilterConfiguration>) {
        super('CombinedServiceCallServiceFilterConfiguration')
        Object.assign(this, init)
    }
}

export class ConsulServiceCallServiceDiscoveryConfiguration extends CamelElement {
    password?: string;
    aclToken?: string;
    readTimeoutMillis?: number;
    connectTimeoutMillis?: number;
    datacenter?: string;
    writeTimeoutMillis?: number;
    id?: string;
    userName?: string;
    blockSeconds?: number;
    properties?: PropertyDefinition[] = [];
    url?: string
    public constructor(init?: Partial<ConsulServiceCallServiceDiscoveryConfiguration>) {
        super('ConsulServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class CustomServiceCallServiceFilterConfiguration extends CamelElement {
    ref?: string;
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<CustomServiceCallServiceFilterConfiguration>) {
        super('CustomServiceCallServiceFilterConfiguration')
        Object.assign(this, init)
    }
}

export class DefaultServiceCallServiceLoadBalancerConfiguration extends CamelElement {
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<DefaultServiceCallServiceLoadBalancerConfiguration>) {
        super('DefaultServiceCallServiceLoadBalancerConfiguration')
        Object.assign(this, init)
    }
}

export class DnsServiceCallServiceDiscoveryConfiguration extends CamelElement {
    domain?: string;
    proto?: string;
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<DnsServiceCallServiceDiscoveryConfiguration>) {
        super('DnsServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class HealthyServiceCallServiceFilterConfiguration extends CamelElement {
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<HealthyServiceCallServiceFilterConfiguration>) {
        super('HealthyServiceCallServiceFilterConfiguration')
        Object.assign(this, init)
    }
}

export class KubernetesServiceCallServiceDiscoveryConfiguration extends CamelElement {
    lookup?: string;
    portProtocol?: string;
    caCertData?: string;
    portName?: string;
    oauthToken?: string;
    clientKeyAlgo?: string;
    clientCertFile?: string;
    dnsDomain?: string;
    password?: string;
    apiVersion?: string;
    clientKeyData?: string;
    masterUrl?: string;
    namespace?: string;
    clientCertData?: string;
    caCertFile?: string;
    clientKeyFile?: string;
    id?: string;
    clientKeyPassphrase?: string;
    properties?: PropertyDefinition[] = [];
    trustCerts?: boolean;
    username?: string
    public constructor(init?: Partial<KubernetesServiceCallServiceDiscoveryConfiguration>) {
        super('KubernetesServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class PassThroughServiceCallServiceFilterConfiguration extends CamelElement {
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<PassThroughServiceCallServiceFilterConfiguration>) {
        super('PassThroughServiceCallServiceFilterConfiguration')
        Object.assign(this, init)
    }
}

export class ServiceCallConfigurationDefinition extends CamelElement {
    defaultLoadBalancer?: DefaultServiceCallServiceLoadBalancerConfiguration;
    serviceDiscoveryRef?: string;
    expression?: ServiceCallExpressionConfiguration;
    kubernetesServiceDiscovery?: KubernetesServiceCallServiceDiscoveryConfiguration;
    pattern?: string;
    customServiceFilter?: CustomServiceCallServiceFilterConfiguration;
    zookeeperServiceDiscovery?: ZooKeeperServiceCallServiceDiscoveryConfiguration;
    uri?: string;
    blacklistServiceFilter?: BlacklistServiceCallServiceFilterConfiguration;
    component?: string;
    expressionRef?: string;
    passThroughServiceFilter?: PassThroughServiceCallServiceFilterConfiguration;
    cachingServiceDiscovery?: CachingServiceCallServiceDiscoveryConfiguration;
    dnsServiceDiscovery?: DnsServiceCallServiceDiscoveryConfiguration;
    healthyServiceFilter?: HealthyServiceCallServiceFilterConfiguration;
    stepName?: string = 'serviceCallConfiguration';
    loadBalancerRef?: string;
    serviceFilterRef?: string;
    combinedServiceFilter?: CombinedServiceCallServiceFilterConfiguration;
    serviceChooserRef?: string;
    consulServiceDiscovery?: ConsulServiceCallServiceDiscoveryConfiguration;
    id?: string;
    staticServiceDiscovery?: StaticServiceCallServiceDiscoveryConfiguration;
    combinedServiceDiscovery?: CombinedServiceCallServiceDiscoveryConfiguration
    public constructor(init?: Partial<ServiceCallConfigurationDefinition>) {
        super('ServiceCallConfigurationDefinition')
        Object.assign(this, init)
    }
}

export class ServiceCallDefinition extends CamelElement {
    pattern?: string;
    description?: string;
    blacklistServiceFilter?: BlacklistServiceCallServiceFilterConfiguration;
    expressionRef?: string;
    passThroughServiceFilter?: PassThroughServiceCallServiceFilterConfiguration;
    dnsServiceDiscovery?: DnsServiceCallServiceDiscoveryConfiguration;
    healthyServiceFilter?: HealthyServiceCallServiceFilterConfiguration;
    stepName?: string = 'serviceCall';
    serviceChooserRef?: string;
    consulServiceDiscovery?: ConsulServiceCallServiceDiscoveryConfiguration;
    id?: string;
    defaultLoadBalancer?: DefaultServiceCallServiceLoadBalancerConfiguration;
    serviceDiscoveryRef?: string;
    expression?: ServiceCallExpressionConfiguration;
    configurationRef?: string;
    kubernetesServiceDiscovery?: KubernetesServiceCallServiceDiscoveryConfiguration;
    customServiceFilter?: CustomServiceCallServiceFilterConfiguration;
    zookeeperServiceDiscovery?: ZooKeeperServiceCallServiceDiscoveryConfiguration;
    uri?: string;
    component?: string;
    inheritErrorHandler?: boolean;
    cachingServiceDiscovery?: CachingServiceCallServiceDiscoveryConfiguration;
    loadBalancerRef?: string;
    serviceFilterRef?: string;
    combinedServiceFilter?: CombinedServiceCallServiceFilterConfiguration;
    name: string = '';
    staticServiceDiscovery?: StaticServiceCallServiceDiscoveryConfiguration;
    combinedServiceDiscovery?: CombinedServiceCallServiceDiscoveryConfiguration
    public constructor(init?: Partial<ServiceCallDefinition>) {
        super('ServiceCallDefinition')
        Object.assign(this, init)
    }
}

export class ServiceCallExpressionConfiguration extends CamelElement {
    hostHeader?: string;
    expressionType?: ExpressionDefinition;
    id?: string;
    portHeader?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<ServiceCallExpressionConfiguration>) {
        super('ServiceCallExpressionConfiguration')
        Object.assign(this, init)
    }
}

export class ServiceCallServiceChooserConfiguration extends CamelElement {
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<ServiceCallServiceChooserConfiguration>) {
        super('ServiceCallServiceChooserConfiguration')
        Object.assign(this, init)
    }
}

export class ServiceCallServiceDiscoveryConfiguration extends CamelElement {
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<ServiceCallServiceDiscoveryConfiguration>) {
        super('ServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class ServiceCallServiceFilterConfiguration extends CamelElement {
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<ServiceCallServiceFilterConfiguration>) {
        super('ServiceCallServiceFilterConfiguration')
        Object.assign(this, init)
    }
}

export class ServiceCallServiceLoadBalancerConfiguration extends CamelElement {
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<ServiceCallServiceLoadBalancerConfiguration>) {
        super('ServiceCallServiceLoadBalancerConfiguration')
        Object.assign(this, init)
    }
}

export class StaticServiceCallServiceDiscoveryConfiguration extends CamelElement {
    servers?: string[] = [];
    id?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<StaticServiceCallServiceDiscoveryConfiguration>) {
        super('StaticServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class ZooKeeperServiceCallServiceDiscoveryConfiguration extends CamelElement {
    nodes: string = '';
    reconnectMaxRetries?: string;
    basePath: string = '';
    reconnectBaseSleepTime?: string;
    namespace?: string;
    reconnectMaxSleepTime?: string;
    sessionTimeout?: string;
    id?: string;
    connectionTimeout?: string;
    properties?: PropertyDefinition[] = []
    public constructor(init?: Partial<ZooKeeperServiceCallServiceDiscoveryConfiguration>) {
        super('ZooKeeperServiceCallServiceDiscoveryConfiguration')
        Object.assign(this, init)
    }
}

export class BatchResequencerConfig extends CamelElement {
    batchSize?: number;
    reverse?: boolean;
    allowDuplicates?: boolean;
    batchTimeout?: string;
    ignoreInvalidExchanges?: boolean
    public constructor(init?: Partial<BatchResequencerConfig>) {
        super('BatchResequencerConfig')
        Object.assign(this, init)
    }
}

export class StreamResequencerConfig extends CamelElement {
    comparator?: string;
    timeout?: string;
    capacity?: number;
    deliveryAttemptInterval?: string;
    ignoreInvalidExchanges?: boolean;
    rejectOld?: boolean
    public constructor(init?: Partial<StreamResequencerConfig>) {
        super('StreamResequencerConfig')
        Object.assign(this, init)
    }
}

export class ASN1DataFormat extends CamelElement {
    dataFormatName?: string = 'asn1';
    usingIterator?: boolean;
    id?: string;
    unmarshalType?: string
    public constructor(init?: Partial<ASN1DataFormat>) {
        super('ASN1DataFormat')
        Object.assign(this, init)
    }
}

export class Any23DataFormat extends CamelElement {
    extractors?: string[] = [];
    configuration?: PropertyDefinition[] = [];
    dataFormatName?: string = 'any23';
    baseUri?: string;
    id?: string;
    outputFormat?: string
    public constructor(init?: Partial<Any23DataFormat>) {
        super('Any23DataFormat')
        Object.assign(this, init)
    }
}

export class AvroDataFormat extends CamelElement {
    allowUnmarshallType?: boolean;
    include?: string;
    contentTypeHeader?: boolean;
    jsonView?: string;
    dataFormatName?: string = 'avro';
    autoDiscoverSchemaResolver?: boolean;
    timezone?: string;
    instanceClassName?: string;
    moduleClassNames?: string;
    allowJmsType?: boolean;
    enableFeatures?: string;
    unmarshalType?: string;
    useList?: boolean;
    disableFeatures?: string;
    moduleRefs?: string;
    schemaResolver?: string;
    collectionType?: string;
    useDefaultObjectMapper?: boolean;
    library?: string;
    objectMapper?: string;
    autoDiscoverObjectMapper?: boolean;
    id?: string
    public constructor(init?: Partial<AvroDataFormat>) {
        super('AvroDataFormat')
        Object.assign(this, init)
    }
}

export class BarcodeDataFormat extends CamelElement {
    barcodeFormat?: string;
    dataFormatName?: string = 'barcode';
    width?: number;
    id?: string;
    imageType?: string;
    height?: number
    public constructor(init?: Partial<BarcodeDataFormat>) {
        super('BarcodeDataFormat')
        Object.assign(this, init)
    }
}

export class Base64DataFormat extends CamelElement {
    dataFormatName?: string = 'base64';
    urlSafe?: boolean;
    id?: string;
    lineSeparator?: string;
    lineLength?: number
    public constructor(init?: Partial<Base64DataFormat>) {
        super('Base64DataFormat')
        Object.assign(this, init)
    }
}

export class BindyDataFormat extends CamelElement {
    unwrapSingleInstance?: boolean;
    dataFormatName?: string = 'bindy';
    id?: string;
    locale?: string;
    type: string = '';
    allowEmptyStream?: boolean;
    classType?: string
    public constructor(init?: Partial<BindyDataFormat>) {
        super('BindyDataFormat')
        Object.assign(this, init)
    }
}

export class CBORDataFormat extends CamelElement {
    allowUnmarshallType?: boolean;
    collectionType?: string;
    useDefaultObjectMapper?: boolean;
    objectMapper?: string;
    prettyPrint?: boolean;
    dataFormatName?: string = 'cbor';
    allowJmsType?: boolean;
    id?: string;
    enableFeatures?: string;
    unmarshalType?: string;
    useList?: boolean;
    disableFeatures?: string
    public constructor(init?: Partial<CBORDataFormat>) {
        super('CBORDataFormat')
        Object.assign(this, init)
    }
}

export class CryptoDataFormat extends CamelElement {
    shouldAppendHmac?: boolean;
    inline?: boolean;
    macAlgorithm?: string;
    algorithmParameterRef?: string;
    dataFormatName?: string = 'crypto';
    cryptoProvider?: string;
    initVectorRef?: string;
    keyRef?: string;
    id?: string;
    algorithm?: string;
    bufferSize?: number
    public constructor(init?: Partial<CryptoDataFormat>) {
        super('CryptoDataFormat')
        Object.assign(this, init)
    }
}

export class CsvDataFormat extends CamelElement {
    escapeDisabled?: boolean;
    ignoreEmptyLines?: boolean;
    recordConverterRef?: string;
    trailingDelimiter?: boolean;
    headerDisabled?: boolean;
    lazyLoad?: boolean;
    commentMarkerDisabled?: boolean;
    skipHeaderRecord?: boolean;
    quote?: string;
    trim?: boolean;
    useMaps?: boolean;
    delimiter?: string;
    nullString?: string;
    allowMissingColumnNames?: boolean;
    id?: string;
    escape?: string;
    nullStringDisabled?: boolean;
    commentMarker?: string;
    dataFormatName?: string = 'csv';
    formatRef?: string;
    quoteMode?: string;
    formatName?: string;
    ignoreSurroundingSpaces?: boolean;
    quoteDisabled?: boolean;
    useOrderedMaps?: boolean;
    header?: string[] = [];
    ignoreHeaderCase?: boolean;
    recordSeparatorDisabled?: string;
    captureHeaderRecord?: boolean;
    marshallerFactoryRef?: string;
    recordSeparator?: string
    public constructor(init?: Partial<CsvDataFormat>) {
        super('CsvDataFormat')
        Object.assign(this, init)
    }
}

export class CustomDataFormat extends CamelElement {
    ref: string = '';
    dataFormatName?: string = 'custom';
    id?: string
    public constructor(init?: Partial<CustomDataFormat>) {
        super('CustomDataFormat')
        Object.assign(this, init)
    }
}

export class DataFormatsDefinition extends CamelElement {
    univocityCsv?: UniVocityCsvDataFormat;
    protobuf?: ProtobufDataFormat | string;
    tarFile?: TarFileDataFormat;
    tidyMarkup?: TidyMarkupDataFormat;
    csv?: CsvDataFormat | string;
    base64?: Base64DataFormat;
    zipDeflater?: ZipDeflaterDataFormat;
    bindy?: BindyDataFormat;
    syslog?: SyslogDataFormat;
    zipFile?: ZipFileDataFormat;
    jaxb?: JaxbDataFormat;
    rss?: RssDataFormat;
    stepName?: string = 'dataFormats';
    mimeMultipart?: MimeMultipartDataFormat;
    asn1?: ASN1DataFormat | string;
    pgp?: PGPDataFormat;
    thrift?: ThriftDataFormat | string;
    json?: JsonDataFormat;
    lzf?: LZFDataFormat;
    fhirXml?: FhirXmlDataFormat;
    barcode?: BarcodeDataFormat;
    avro?: AvroDataFormat | string;
    yaml?: YAMLDataFormat;
    fhirJson?: FhirJsonDataFormat;
    any23?: Any23DataFormat | string;
    custom?: CustomDataFormat | string;
    flatpack?: FlatpackDataFormat;
    cbor?: CBORDataFormat;
    crypto?: CryptoDataFormat;
    univocityTsv?: UniVocityTsvDataFormat;
    hl7?: HL7DataFormat;
    jsonApi?: JsonApiDataFormat;
    xmlSecurity?: XMLSecurityDataFormat;
    ical?: IcalDataFormat;
    univocityFixed?: UniVocityFixedDataFormat;
    jacksonXml?: JacksonXMLDataFormat;
    grok?: GrokDataFormat;
    xstream?: XStreamDataFormat | string;
    gzipDeflater?: GzipDeflaterDataFormat;
    soap?: SoapDataFormat | string
    public constructor(init?: Partial<DataFormatsDefinition>) {
        super('DataFormatsDefinition')
        Object.assign(this, init)
    }
}

export class FhirJsonDataFormat extends CamelElement {
    contentTypeHeader?: boolean;
    dontStripVersionsFromReferencesAtPaths?: string[] = [];
    prettyPrint?: boolean;
    dataFormatName?: string = 'fhirJson';
    dontEncodeElements?: string[] = [];
    summaryMode?: boolean;
    encodeElementsAppliesToChildResourcesOnly?: boolean;
    serverBaseUrl?: string;
    fhirVersion?: string;
    suppressNarratives?: boolean;
    encodeElements?: string[] = [];
    stripVersionsFromReferences?: boolean;
    id?: string;
    omitResourceId?: boolean;
    overrideResourceIdWithBundleEntryFullUrl?: boolean
    public constructor(init?: Partial<FhirJsonDataFormat>) {
        super('FhirJsonDataFormat')
        Object.assign(this, init)
    }
}

export class FhirXmlDataFormat extends CamelElement {
    contentTypeHeader?: boolean;
    dontStripVersionsFromReferencesAtPaths?: string[] = [];
    prettyPrint?: boolean;
    dataFormatName?: string = 'fhirXml';
    dontEncodeElements?: string[] = [];
    summaryMode?: boolean;
    encodeElementsAppliesToChildResourcesOnly?: boolean;
    serverBaseUrl?: string;
    fhirVersion?: string;
    suppressNarratives?: boolean;
    encodeElements?: string[] = [];
    stripVersionsFromReferences?: boolean;
    id?: string;
    omitResourceId?: boolean;
    overrideResourceIdWithBundleEntryFullUrl?: boolean
    public constructor(init?: Partial<FhirXmlDataFormat>) {
        super('FhirXmlDataFormat')
        Object.assign(this, init)
    }
}

export class FlatpackDataFormat extends CamelElement {
    allowShortLines?: boolean;
    dataFormatName?: string = 'flatpack';
    delimiter?: string;
    definition?: string;
    fixed?: boolean;
    id?: string;
    ignoreFirstRecord?: boolean;
    parserFactoryRef?: string;
    textQualifier?: string;
    ignoreExtraColumns?: boolean
    public constructor(init?: Partial<FlatpackDataFormat>) {
        super('FlatpackDataFormat')
        Object.assign(this, init)
    }
}

export class GrokDataFormat extends CamelElement {
    flattened?: boolean;
    namedOnly?: boolean;
    dataFormatName?: string = 'grok';
    pattern: string = '';
    allowMultipleMatchesPerLine?: boolean;
    id?: string
    public constructor(init?: Partial<GrokDataFormat>) {
        super('GrokDataFormat')
        Object.assign(this, init)
    }
}

export class GzipDeflaterDataFormat extends CamelElement {
    dataFormatName?: string = 'gzipDeflater';
    id?: string
    public constructor(init?: Partial<GzipDeflaterDataFormat>) {
        super('GzipDeflaterDataFormat')
        Object.assign(this, init)
    }
}

export class HL7DataFormat extends CamelElement {
    dataFormatName?: string = 'hl7';
    id?: string;
    validate?: boolean
    public constructor(init?: Partial<HL7DataFormat>) {
        super('HL7DataFormat')
        Object.assign(this, init)
    }
}

export class IcalDataFormat extends CamelElement {
    validating?: boolean;
    dataFormatName?: string = 'ical';
    id?: string
    public constructor(init?: Partial<IcalDataFormat>) {
        super('IcalDataFormat')
        Object.assign(this, init)
    }
}

export class JacksonXMLDataFormat extends CamelElement {
    allowUnmarshallType?: boolean;
    include?: string;
    contentTypeHeader?: boolean;
    prettyPrint?: boolean;
    jsonView?: string;
    dataFormatName?: string = 'jacksonXml';
    timezone?: string;
    moduleClassNames?: string;
    allowJmsType?: boolean;
    enableFeatures?: string;
    unmarshalType?: string;
    useList?: boolean;
    disableFeatures?: string;
    moduleRefs?: string;
    collectionType?: string;
    id?: string;
    enableJaxbAnnotationModule?: boolean;
    xmlMapper?: string
    public constructor(init?: Partial<JacksonXMLDataFormat>) {
        super('JacksonXMLDataFormat')
        Object.assign(this, init)
    }
}

export class JaxbDataFormat extends CamelElement {
    schema?: string;
    contentTypeHeader?: boolean;
    prettyPrint?: boolean;
    dataFormatName?: string = 'jaxb';
    contextPathIsClassName?: boolean;
    schemaLocation?: string;
    contextPath: string = '';
    schemaSeverityLevel?: string;
    xmlStreamWriterWrapper?: string;
    noNamespaceSchemaLocation?: string;
    encoding?: string;
    mustBeJaxbElement?: boolean;
    filterNonXmlChars?: boolean;
    fragment?: boolean;
    objectFactory?: boolean;
    namespacePrefixRef?: string;
    partClass?: string;
    ignoreJaxbElement?: boolean;
    id?: string;
    jaxbProviderProperties?: string;
    partNamespace?: string
    public constructor(init?: Partial<JaxbDataFormat>) {
        super('JaxbDataFormat')
        Object.assign(this, init)
    }
}

export class JsonApiDataFormat extends CamelElement {
    dataFormatName?: string = 'jsonApi';
    id?: string;
    mainFormatType?: string
    public constructor(init?: Partial<JsonApiDataFormat>) {
        super('JsonApiDataFormat')
        Object.assign(this, init)
    }
}

export class JsonDataFormat extends CamelElement {
    contentTypeHeader?: boolean;
    timezone?: string;
    moduleClassNames?: string;
    allowJmsType?: boolean;
    enableFeatures?: string;
    unmarshalType?: string;
    library?: string;
    permissions?: string;
    autoDiscoverObjectMapper?: boolean;
    id?: string;
    allowUnmarshallType?: boolean;
    include?: string;
    prettyPrint?: boolean;
    jsonView?: string;
    dataFormatName?: string = 'json';
    autoDiscoverSchemaResolver?: boolean;
    useList?: boolean;
    disableFeatures?: string;
    moduleRefs?: string;
    schemaResolver?: string;
    collectionType?: string;
    useDefaultObjectMapper?: boolean;
    objectMapper?: string;
    dropRootNode?: boolean;
    namingStrategy?: string
    public constructor(init?: Partial<JsonDataFormat>) {
        super('JsonDataFormat')
        Object.assign(this, init)
    }
}

export class LZFDataFormat extends CamelElement {
    dataFormatName?: string = 'lzf';
    id?: string;
    usingParallelCompression?: boolean
    public constructor(init?: Partial<LZFDataFormat>) {
        super('LZFDataFormat')
        Object.assign(this, init)
    }
}

export class MimeMultipartDataFormat extends CamelElement {
    headersInline?: boolean;
    multipartSubType?: string;
    multipartWithoutAttachment?: boolean;
    dataFormatName?: string = 'mimeMultipart';
    id?: string;
    includeHeaders?: string;
    binaryContent?: boolean
    public constructor(init?: Partial<MimeMultipartDataFormat>) {
        super('MimeMultipartDataFormat')
        Object.assign(this, init)
    }
}

export class PGPDataFormat extends CamelElement {
    dataFormatName?: string = 'pgp';
    armored?: boolean;
    signaturePassword?: string;
    signatureKeyRing?: string;
    keyFileName?: string;
    signatureVerificationOption?: string;
    signatureKeyUserid?: string;
    integrity?: boolean;
    password?: string;
    provider?: string;
    compressionAlgorithm?: number;
    keyUserid?: string;
    signatureKeyFileName?: string;
    id?: string;
    hashAlgorithm?: number;
    algorithm?: number
    public constructor(init?: Partial<PGPDataFormat>) {
        super('PGPDataFormat')
        Object.assign(this, init)
    }
}

export class ProtobufDataFormat extends CamelElement {
    allowUnmarshallType?: boolean;
    include?: string;
    contentTypeHeader?: boolean;
    contentTypeFormat?: string;
    jsonView?: string;
    dataFormatName?: string = 'protobuf';
    autoDiscoverSchemaResolver?: boolean;
    timezone?: string;
    moduleClassNames?: string;
    allowJmsType?: boolean;
    instanceClass?: string;
    enableFeatures?: string;
    unmarshalType?: string;
    useList?: boolean;
    disableFeatures?: string;
    moduleRefs?: string;
    schemaResolver?: string;
    collectionType?: string;
    useDefaultObjectMapper?: boolean;
    library?: string;
    objectMapper?: string;
    autoDiscoverObjectMapper?: boolean;
    id?: string
    public constructor(init?: Partial<ProtobufDataFormat>) {
        super('ProtobufDataFormat')
        Object.assign(this, init)
    }
}

export class RssDataFormat extends CamelElement {
    dataFormatName?: string = 'rss';
    id?: string
    public constructor(init?: Partial<RssDataFormat>) {
        super('RssDataFormat')
        Object.assign(this, init)
    }
}

export class SoapDataFormat extends CamelElement {
    schema?: string;
    namespacePrefixRef?: string;
    dataFormatName?: string = 'soap';
    elementNameStrategyRef?: string;
    contextPath: string = '';
    id?: string;
    encoding?: string;
    version?: string
    public constructor(init?: Partial<SoapDataFormat>) {
        super('SoapDataFormat')
        Object.assign(this, init)
    }
}

export class SyslogDataFormat extends CamelElement {
    dataFormatName?: string = 'syslog';
    id?: string
    public constructor(init?: Partial<SyslogDataFormat>) {
        super('SyslogDataFormat')
        Object.assign(this, init)
    }
}

export class TarFileDataFormat extends CamelElement {
    maxDecompressedSize?: number;
    dataFormatName?: string = 'tarFile';
    usingIterator?: boolean;
    id?: string;
    preservePathElements?: boolean;
    allowEmptyDirectory?: boolean
    public constructor(init?: Partial<TarFileDataFormat>) {
        super('TarFileDataFormat')
        Object.assign(this, init)
    }
}

export class ThriftDataFormat extends CamelElement {
    contentTypeHeader?: boolean;
    contentTypeFormat?: string;
    dataFormatName?: string = 'thrift';
    instanceClass?: string;
    id?: string
    public constructor(init?: Partial<ThriftDataFormat>) {
        super('ThriftDataFormat')
        Object.assign(this, init)
    }
}

export class TidyMarkupDataFormat extends CamelElement {
    omitXmlDeclaration?: boolean;
    dataObjectType?: string;
    dataFormatName?: string = 'tidyMarkup';
    id?: string
    public constructor(init?: Partial<TidyMarkupDataFormat>) {
        super('TidyMarkupDataFormat')
        Object.assign(this, init)
    }
}

export class UniVocityCsvDataFormat extends CamelElement {
    headerExtractionEnabled?: boolean;
    skipEmptyLines?: boolean;
    dataFormatName?: string = 'univocityCsv';
    asMap?: boolean;
    ignoreLeadingWhitespaces?: boolean;
    univocityHeader?: UniVocityHeader[] = [];
    ignoreTrailingWhitespaces?: boolean;
    lineSeparator?: string;
    lazyLoad?: boolean;
    nullValue?: string;
    quoteAllFields?: boolean;
    normalizedLineSeparator?: string;
    emptyValue?: string;
    quote?: string;
    quoteEscape?: string;
    delimiter?: string;
    headersDisabled?: boolean;
    comment?: string;
    id?: string;
    numberOfRecordsToRead?: number
    public constructor(init?: Partial<UniVocityCsvDataFormat>) {
        super('UniVocityCsvDataFormat')
        Object.assign(this, init)
    }
}

export class UniVocityFixedDataFormat extends CamelElement {
    headerExtractionEnabled?: boolean;
    padding?: string;
    recordEndsOnNewline?: boolean;
    skipEmptyLines?: boolean;
    dataFormatName?: string = 'univocityFixed';
    asMap?: boolean;
    ignoreLeadingWhitespaces?: boolean;
    univocityHeader?: UniVocityHeader[] = [];
    ignoreTrailingWhitespaces?: boolean;
    lineSeparator?: string;
    lazyLoad?: boolean;
    nullValue?: string;
    normalizedLineSeparator?: string;
    emptyValue?: string;
    headersDisabled?: boolean;
    comment?: string;
    id?: string;
    numberOfRecordsToRead?: number;
    skipTrailingCharsUntilNewline?: boolean
    public constructor(init?: Partial<UniVocityFixedDataFormat>) {
        super('UniVocityFixedDataFormat')
        Object.assign(this, init)
    }
}

export class UniVocityHeader extends CamelElement {
    length?: string;
    name?: string
    public constructor(init?: Partial<UniVocityHeader>) {
        super('UniVocityHeader')
        Object.assign(this, init)
    }
}

export class UniVocityTsvDataFormat extends CamelElement {
    escapeChar?: string;
    headerExtractionEnabled?: boolean;
    skipEmptyLines?: boolean;
    dataFormatName?: string = 'univocityTsv';
    asMap?: boolean;
    ignoreLeadingWhitespaces?: boolean;
    univocityHeader?: UniVocityHeader[] = [];
    ignoreTrailingWhitespaces?: boolean;
    lineSeparator?: string;
    lazyLoad?: boolean;
    nullValue?: string;
    normalizedLineSeparator?: string;
    emptyValue?: string;
    headersDisabled?: boolean;
    comment?: string;
    id?: string;
    numberOfRecordsToRead?: number
    public constructor(init?: Partial<UniVocityTsvDataFormat>) {
        super('UniVocityTsvDataFormat')
        Object.assign(this, init)
    }
}

export class XMLSecurityDataFormat extends CamelElement {
    addKeyValueForEncryptedKey?: boolean;
    keyCipherAlgorithm?: string;
    dataFormatName?: string = 'xmlSecurity';
    recipientKeyAlias?: string;
    keyOrTrustStoreParametersRef?: string;
    digestAlgorithm?: string;
    mgfAlgorithm?: string;
    secureTagContents?: boolean;
    passPhraseByte?: string;
    keyPassword?: string;
    secureTag?: string;
    id?: string;
    xmlCipherAlgorithm?: string;
    passPhrase?: string
    public constructor(init?: Partial<XMLSecurityDataFormat>) {
        super('XMLSecurityDataFormat')
        Object.assign(this, init)
    }
}

export class XStreamDataFormat extends CamelElement {
    mode?: string;
    omitFields?: PropertyDefinition[] = [];
    aliases?: PropertyDefinition[] = [];
    contentTypeHeader?: boolean;
    driver?: string;
    driverRef?: string;
    implicitCollections?: PropertyDefinition[] = [];
    dataFormatName?: string = 'xstream';
    permissions?: string;
    converters?: PropertyDefinition[] = [];
    id?: string;
    encoding?: string
    public constructor(init?: Partial<XStreamDataFormat>) {
        super('XStreamDataFormat')
        Object.assign(this, init)
    }
}

export class YAMLDataFormat extends CamelElement {
    resolver?: string;
    _constructor?: string;
    prettyFlow?: boolean;
    dataFormatName?: string = 'yaml';
    allowAnyType?: boolean;
    representer?: string;
    unmarshalType?: string;
    library?: string;
    typeFilter?: YAMLTypeFilterDefinition[] = [];
    maxAliasesForCollections?: number;
    dumperOptions?: string;
    id?: string;
    useApplicationContextClassLoader?: boolean;
    allowRecursiveKeys?: boolean
    public constructor(init?: Partial<YAMLDataFormat>) {
        super('YAMLDataFormat')
        Object.assign(this, init)
    }
}

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

export class ZipDeflaterDataFormat extends CamelElement {
    dataFormatName?: string = 'zipDeflater';
    id?: string;
    compressionLevel?: string
    public constructor(init?: Partial<ZipDeflaterDataFormat>) {
        super('ZipDeflaterDataFormat')
        Object.assign(this, init)
    }
}

export class ZipFileDataFormat extends CamelElement {
    maxDecompressedSize?: number;
    dataFormatName?: string = 'zipFile';
    usingIterator?: boolean;
    id?: string;
    preservePathElements?: boolean;
    allowEmptyDirectory?: boolean
    public constructor(init?: Partial<ZipFileDataFormat>) {
        super('ZipFileDataFormat')
        Object.assign(this, init)
    }
}

export class DeadLetterChannelDefinition extends CamelElement {
    executorServiceRef?: string;
    redeliveryPolicy?: RedeliveryPolicyDefinition;
    level?: string;
    loggerRef?: string;
    useOriginalMessage?: boolean;
    deadLetterHandleNewException?: boolean;
    deadLetterUri: string = '';
    onRedeliveryRef?: string;
    retryWhileRef?: string;
    logName?: string;
    stepName?: string = 'deadLetterChannel';
    useOriginalBody?: boolean;
    id?: string;
    onPrepareFailureRef?: string;
    onExceptionOccurredRef?: string;
    redeliveryPolicyRef?: string
    public constructor(init?: Partial<DeadLetterChannelDefinition>) {
        super('DeadLetterChannelDefinition')
        Object.assign(this, init)
    }
}

export class DefaultErrorHandlerDefinition extends CamelElement {
    executorServiceRef?: string;
    redeliveryPolicy?: RedeliveryPolicyDefinition;
    level?: string;
    loggerRef?: string;
    useOriginalMessage?: boolean;
    onRedeliveryRef?: string;
    retryWhileRef?: string;
    logName?: string;
    stepName?: string = 'defaultErrorHandler';
    useOriginalBody?: boolean;
    id?: string;
    onPrepareFailureRef?: string;
    onExceptionOccurredRef?: string;
    redeliveryPolicyRef?: string
    public constructor(init?: Partial<DefaultErrorHandlerDefinition>) {
        super('DefaultErrorHandlerDefinition')
        Object.assign(this, init)
    }
}

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

export class JtaTransactionErrorHandlerDefinition extends CamelElement {
    executorServiceRef?: string;
    redeliveryPolicy?: RedeliveryPolicyDefinition;
    level?: string;
    loggerRef?: string;
    useOriginalMessage?: boolean;
    onRedeliveryRef?: string;
    retryWhileRef?: string;
    logName?: string;
    stepName?: string = 'jtaTransactionErrorHandler';
    useOriginalBody?: boolean;
    rollbackLoggingLevel?: string;
    id?: string;
    onPrepareFailureRef?: string;
    transactedPolicyRef?: string;
    onExceptionOccurredRef?: string;
    redeliveryPolicyRef?: string
    public constructor(init?: Partial<JtaTransactionErrorHandlerDefinition>) {
        super('JtaTransactionErrorHandlerDefinition')
        Object.assign(this, init)
    }
}

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

export class SpringTransactionErrorHandlerDefinition extends CamelElement {
    executorServiceRef?: string;
    redeliveryPolicy?: RedeliveryPolicyDefinition;
    level?: string;
    loggerRef?: string;
    useOriginalMessage?: boolean;
    onRedeliveryRef?: string;
    retryWhileRef?: string;
    logName?: string;
    stepName?: string = 'springTransactionErrorHandler';
    useOriginalBody?: boolean;
    rollbackLoggingLevel?: string;
    id?: string;
    onPrepareFailureRef?: string;
    transactedPolicyRef?: string;
    onExceptionOccurredRef?: string;
    redeliveryPolicyRef?: string
    public constructor(init?: Partial<SpringTransactionErrorHandlerDefinition>) {
        super('SpringTransactionErrorHandlerDefinition')
        Object.assign(this, init)
    }
}

export class CSimpleExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'csimple';
    id?: string;
    resultType?: string
    public constructor(init?: Partial<CSimpleExpression>) {
        super('CSimpleExpression')
        Object.assign(this, init)
    }
}

export class ConstantExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'constant';
    id?: string;
    resultType?: string
    public constructor(init?: Partial<ConstantExpression>) {
        super('ConstantExpression')
        Object.assign(this, init)
    }
}

export class DatasonnetExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'datasonnet';
    outputMediaType?: string;
    id?: string;
    resultType?: string;
    bodyMediaType?: string
    public constructor(init?: Partial<DatasonnetExpression>) {
        super('DatasonnetExpression')
        Object.assign(this, init)
    }
}

export class ExchangePropertyExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'exchangeProperty';
    id?: string
    public constructor(init?: Partial<ExchangePropertyExpression>) {
        super('ExchangePropertyExpression')
        Object.assign(this, init)
    }
}

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

export class GroovyExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'groovy';
    id?: string
    public constructor(init?: Partial<GroovyExpression>) {
        super('GroovyExpression')
        Object.assign(this, init)
    }
}

export class HeaderExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'header';
    id?: string
    public constructor(init?: Partial<HeaderExpression>) {
        super('HeaderExpression')
        Object.assign(this, init)
    }
}

export class Hl7TerserExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'hl7terser';
    id?: string
    public constructor(init?: Partial<Hl7TerserExpression>) {
        super('Hl7TerserExpression')
        Object.assign(this, init)
    }
}

export class JoorExpression extends CamelElement {
    preCompile?: boolean;
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'joor';
    id?: string;
    singleQuotes?: boolean;
    resultType?: string
    public constructor(init?: Partial<JoorExpression>) {
        super('JoorExpression')
        Object.assign(this, init)
    }
}

export class JqExpression extends CamelElement {
    expression: string = '';
    headerName?: string;
    trim?: boolean;
    expressionName?: string = 'jq';
    id?: string;
    resultType?: string
    public constructor(init?: Partial<JqExpression>) {
        super('JqExpression')
        Object.assign(this, init)
    }
}

export class JsonPathExpression extends CamelElement {
    expression: string = '';
    headerName?: string;
    trim?: boolean;
    expressionName?: string = 'jsonpath';
    writeAsString?: boolean;
    id?: string;
    allowSimple?: boolean;
    suppressExceptions?: boolean;
    allowEasyPredicate?: boolean;
    resultType?: string;
    option?: string
    public constructor(init?: Partial<JsonPathExpression>) {
        super('JsonPathExpression')
        Object.assign(this, init)
    }
}

export class LanguageExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'language';
    language: string = '';
    id?: string
    public constructor(init?: Partial<LanguageExpression>) {
        super('LanguageExpression')
        Object.assign(this, init)
    }
}

export class MethodCallExpression extends CamelElement {
    ref?: string;
    method?: string;
    trim?: boolean;
    expressionName?: string = 'method';
    scope?: string;
    id?: string;
    beanType?: string
    public constructor(init?: Partial<MethodCallExpression>) {
        super('MethodCallExpression')
        Object.assign(this, init)
    }
}

export class MvelExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'mvel';
    id?: string
    public constructor(init?: Partial<MvelExpression>) {
        super('MvelExpression')
        Object.assign(this, init)
    }
}

export class OgnlExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'ognl';
    id?: string
    public constructor(init?: Partial<OgnlExpression>) {
        super('OgnlExpression')
        Object.assign(this, init)
    }
}

export class RefExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'ref';
    id?: string
    public constructor(init?: Partial<RefExpression>) {
        super('RefExpression')
        Object.assign(this, init)
    }
}

export class SimpleExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'simple';
    id?: string;
    resultType?: string
    public constructor(init?: Partial<SimpleExpression>) {
        super('SimpleExpression')
        Object.assign(this, init)
    }
}

export class SpELExpression extends CamelElement {
    expression: string = '';
    trim?: boolean;
    expressionName?: string = 'spel';
    id?: string
    public constructor(init?: Partial<SpELExpression>) {
        super('SpELExpression')
        Object.assign(this, init)
    }
}

export class TokenizerExpression extends CamelElement {
    endToken?: string;
    headerName?: string;
    skipFirst?: boolean;
    expressionName?: string = 'tokenize';
    inheritNamespaceTagName?: string;
    groupDelimiter?: string;
    token: string = '';
    regex?: boolean;
    includeTokens?: boolean;
    trim?: boolean;
    xml?: boolean;
    id?: string;
    group?: string
    public constructor(init?: Partial<TokenizerExpression>) {
        super('TokenizerExpression')
        Object.assign(this, init)
    }
}

export class XMLTokenizerExpression extends CamelElement {
    mode?: string;
    headerName?: string;
    trim?: boolean;
    expressionName?: string = 'xtokenize';
    namespace?: PropertyDefinition[] = [];
    id?: string;
    group?: number
    public constructor(init?: Partial<XMLTokenizerExpression>) {
        super('XMLTokenizerExpression')
        Object.assign(this, init)
    }
}

export class XPathExpression extends CamelElement {
    preCompile?: boolean;
    expression: string = '';
    headerName?: string;
    documentType?: string;
    expressionName?: string = 'xpath';
    factoryRef?: string;
    saxon?: boolean;
    trim?: boolean;
    objectModel?: string;
    logNamespaces?: boolean;
    namespace?: PropertyDefinition[] = [];
    threadSafety?: boolean;
    id?: string;
    resultType?: string
    public constructor(init?: Partial<XPathExpression>) {
        super('XPathExpression')
        Object.assign(this, init)
    }
}

export class XQueryExpression extends CamelElement {
    expression: string = '';
    headerName?: string;
    configurationRef?: string;
    trim?: boolean;
    expressionName?: string = 'xquery';
    namespace?: PropertyDefinition[] = [];
    id?: string;
    type?: string
    public constructor(init?: Partial<XQueryExpression>) {
        super('XQueryExpression')
        Object.assign(this, init)
    }
}

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

export class FailoverLoadBalancerDefinition extends CamelElement {
    exception?: string[] = [];
    stepName?: string = 'failoverLoadBalancer';
    sticky?: string;
    id?: string;
    maximumFailoverAttempts?: string;
    roundRobin?: string
    public constructor(init?: Partial<FailoverLoadBalancerDefinition>) {
        super('FailoverLoadBalancerDefinition')
        Object.assign(this, init)
    }
}

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

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

export class StickyLoadBalancerDefinition extends CamelElement {
    stepName?: string = 'stickyLoadBalancer';
    correlationExpression?: ExpressionSubElementDefinition;
    id?: string
    public constructor(init?: Partial<StickyLoadBalancerDefinition>) {
        super('StickyLoadBalancerDefinition')
        Object.assign(this, init)
    }
}

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

export class WeightedLoadBalancerDefinition extends CamelElement {
    distributionRatioDelimiter?: string;
    stepName?: string = 'weightedLoadBalancer';
    id?: string;
    distributionRatio: string = '';
    roundRobin?: boolean
    public constructor(init?: Partial<WeightedLoadBalancerDefinition>) {
        super('WeightedLoadBalancerDefinition')
        Object.assign(this, init)
    }
}

export class ApiKeyDefinition extends CamelElement {
    inHeader?: boolean;
    inCookie?: boolean;
    stepName?: string = 'apiKey';
    name: string = '';
    description?: string;
    inQuery?: boolean;
    key: string = ''
    public constructor(init?: Partial<ApiKeyDefinition>) {
        super('ApiKeyDefinition')
        Object.assign(this, init)
    }
}

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

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

export class DeleteDefinition extends CamelElement {
    enableCors?: boolean;
    deprecated?: boolean;
    description?: string;
    type?: string;
    outType?: string;
    path?: string;
    security?: SecurityDefinition[] = [];
    bindingMode?: string;
    stepName?: string = 'delete';
    param?: ParamDefinition[] = [];
    apiDocs?: boolean;
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    produces?: string;
    id?: string;
    to?: string;
    responseMessage?: ResponseMessageDefinition[] = [];
    consumes?: string
    public constructor(init?: Partial<DeleteDefinition>) {
        super('DeleteDefinition')
        Object.assign(this, init)
    }
}

export class GetDefinition extends CamelElement {
    enableCors?: boolean;
    deprecated?: boolean;
    description?: string;
    type?: string;
    outType?: string;
    path?: string;
    security?: SecurityDefinition[] = [];
    bindingMode?: string;
    stepName?: string = 'get';
    param?: ParamDefinition[] = [];
    apiDocs?: boolean;
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    produces?: string;
    id?: string;
    to?: string;
    responseMessage?: ResponseMessageDefinition[] = [];
    consumes?: string
    public constructor(init?: Partial<GetDefinition>) {
        super('GetDefinition')
        Object.assign(this, init)
    }
}

export class HeadDefinition extends CamelElement {
    enableCors?: boolean;
    deprecated?: boolean;
    description?: string;
    type?: string;
    outType?: string;
    path?: string;
    security?: SecurityDefinition[] = [];
    bindingMode?: string;
    stepName?: string = 'head';
    param?: ParamDefinition[] = [];
    apiDocs?: boolean;
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    produces?: string;
    id?: string;
    to?: string;
    responseMessage?: ResponseMessageDefinition[] = [];
    consumes?: string
    public constructor(init?: Partial<HeadDefinition>) {
        super('HeadDefinition')
        Object.assign(this, init)
    }
}

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

export class OAuth2Definition extends CamelElement {
    tokenUrl?: string;
    authorizationUrl?: string;
    stepName?: string = 'oAuth2';
    refreshUrl?: string;
    description?: string;
    scopes?: RestPropertyDefinition[] = [];
    flow?: string;
    key: string = ''
    public constructor(init?: Partial<OAuth2Definition>) {
        super('OAuth2Definition')
        Object.assign(this, init)
    }
}

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

export class ParamDefinition extends CamelElement {
    arrayType?: string;
    examples?: RestPropertyDefinition[] = [];
    stepName?: string = 'param';
    dataFormat?: string;
    defaultValue?: string;
    dataType?: string;
    name: string = '';
    description?: string;
    type: string = '';
    collectionFormat?: string;
    value?: string[] = [];
    required?: boolean
    public constructor(init?: Partial<ParamDefinition>) {
        super('ParamDefinition')
        Object.assign(this, init)
    }
}

export class PatchDefinition extends CamelElement {
    enableCors?: boolean;
    deprecated?: boolean;
    description?: string;
    type?: string;
    outType?: string;
    path?: string;
    security?: SecurityDefinition[] = [];
    bindingMode?: string;
    stepName?: string = 'patch';
    param?: ParamDefinition[] = [];
    apiDocs?: boolean;
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    produces?: string;
    id?: string;
    to?: string;
    responseMessage?: ResponseMessageDefinition[] = [];
    consumes?: string
    public constructor(init?: Partial<PatchDefinition>) {
        super('PatchDefinition')
        Object.assign(this, init)
    }
}

export class PostDefinition extends CamelElement {
    enableCors?: boolean;
    deprecated?: boolean;
    description?: string;
    type?: string;
    outType?: string;
    path?: string;
    security?: SecurityDefinition[] = [];
    bindingMode?: string;
    stepName?: string = 'post';
    param?: ParamDefinition[] = [];
    apiDocs?: boolean;
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    produces?: string;
    id?: string;
    to?: string;
    responseMessage?: ResponseMessageDefinition[] = [];
    consumes?: string
    public constructor(init?: Partial<PostDefinition>) {
        super('PostDefinition')
        Object.assign(this, init)
    }
}

export class PutDefinition extends CamelElement {
    enableCors?: boolean;
    deprecated?: boolean;
    description?: string;
    type?: string;
    outType?: string;
    path?: string;
    security?: SecurityDefinition[] = [];
    bindingMode?: string;
    stepName?: string = 'put';
    param?: ParamDefinition[] = [];
    apiDocs?: boolean;
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    produces?: string;
    id?: string;
    to?: string;
    responseMessage?: ResponseMessageDefinition[] = [];
    consumes?: string
    public constructor(init?: Partial<PutDefinition>) {
        super('PutDefinition')
        Object.assign(this, init)
    }
}

export class ResponseHeaderDefinition extends CamelElement {
    arrayType?: string;
    stepName?: string = 'responseHeader';
    dataFormat?: string;
    dataType?: string;
    name: string = '';
    description?: string;
    collectionFormat?: string;
    value?: string[] = [];
    example?: string
    public constructor(init?: Partial<ResponseHeaderDefinition>) {
        super('ResponseHeaderDefinition')
        Object.assign(this, init)
    }
}

export class ResponseMessageDefinition extends CamelElement {
    code?: string;
    examples?: RestPropertyDefinition[] = [];
    stepName?: string = 'responseMessage';
    header?: ResponseHeaderDefinition[] = [];
    responseModel?: string;
    message: string = ''
    public constructor(init?: Partial<ResponseMessageDefinition>) {
        super('ResponseMessageDefinition')
        Object.assign(this, init)
    }
}

export class RestBindingDefinition extends CamelElement {
    enableCors?: boolean;
    component?: string;
    bindingMode?: string;
    stepName?: string = 'restBinding';
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    produces?: string;
    description?: string;
    id?: string;
    type?: string;
    outType?: string;
    consumes?: string
    public constructor(init?: Partial<RestBindingDefinition>) {
        super('RestBindingDefinition')
        Object.assign(this, init)
    }
}

export class RestConfigurationDefinition extends CamelElement {
    enableCors?: boolean;
    scheme?: string;
    apiContextPath?: string;
    consumerProperty?: RestPropertyDefinition[] = [];
    apiProperty?: RestPropertyDefinition[] = [];
    hostNameResolver?: string;
    componentProperty?: RestPropertyDefinition[] = [];
    corsHeaders?: RestPropertyDefinition[] = [];
    stepName?: string = 'restConfiguration';
    skipBindingOnErrorCode?: boolean;
    clientRequestValidation?: boolean;
    host?: string;
    producerApiDoc?: string;
    producerComponent?: string;
    endpointProperty?: RestPropertyDefinition[] = [];
    useXForwardHeaders?: boolean;
    apiHost?: string;
    contextPath?: string;
    component?: string;
    dataFormatProperty?: RestPropertyDefinition[] = [];
    bindingMode?: string;
    port?: string;
    xmlDataFormat?: string;
    apiComponent?: string;
    apiVendorExtension?: boolean;
    jsonDataFormat?: string
    public constructor(init?: Partial<RestConfigurationDefinition>) {
        super('RestConfigurationDefinition')
        Object.assign(this, init)
    }
}

export class RestDefinition extends CamelElement {
    enableCors?: boolean;
    securityRequirements?: SecurityDefinition[] = [];
    description?: string;
    delete?: DeleteDefinition[] = [];
    put?: PutDefinition[] = [];
    head?: HeadDefinition[] = [];
    patch?: PatchDefinition[] = [];
    path?: string;
    bindingMode?: string;
    post?: PostDefinition[] = [];
    stepName?: string = 'rest';
    apiDocs?: boolean;
    skipBindingOnErrorCode?: boolean;
    get?: GetDefinition[] = [];
    clientRequestValidation?: boolean;
    produces?: string;
    id?: string;
    tag?: string;
    securityDefinitions?: RestSecuritiesDefinition;
    consumes?: string
    public constructor(init?: Partial<RestDefinition>) {
        super('RestDefinition')
        Object.assign(this, init)
    }
}

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

export class RestSecuritiesDefinition extends CamelElement {
    openIdConnect?: OpenIdConnectDefinition;
    apiKey?: ApiKeyDefinition;
    stepName?: string = 'restSecurities';
    basicAuth?: BasicAuthDefinition;
    mutualTls?: MutualTLSDefinition;
    bearer?: BearerTokenDefinition;
    oauth2?: OAuth2Definition
    public constructor(init?: Partial<RestSecuritiesDefinition>) {
        super('RestSecuritiesDefinition')
        Object.assign(this, init)
    }
}

export class RestsDefinition extends CamelElement {
    rest?: RestDefinition[] = [];
    stepName?: string = 'rests';
    description?: string;
    id?: string
    public constructor(init?: Partial<RestsDefinition>) {
        super('RestsDefinition')
        Object.assign(this, init)
    }
}

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

export class CustomTransformerDefinition extends CamelElement {
    ref?: string;
    toType?: string;
    fromType?: string;
    scheme?: string;
    stepName?: string = 'customTransformer';
    className?: string
    public constructor(init?: Partial<CustomTransformerDefinition>) {
        super('CustomTransformerDefinition')
        Object.assign(this, init)
    }
}

export class DataFormatTransformerDefinition extends CamelElement {
    univocityCsv?: UniVocityCsvDataFormat;
    protobuf?: ProtobufDataFormat | string;
    tarFile?: TarFileDataFormat;
    tidyMarkup?: TidyMarkupDataFormat;
    scheme?: string;
    csv?: CsvDataFormat | string;
    base64?: Base64DataFormat;
    zipDeflater?: ZipDeflaterDataFormat;
    bindy?: BindyDataFormat;
    syslog?: SyslogDataFormat;
    zipFile?: ZipFileDataFormat;
    jaxb?: JaxbDataFormat;
    rss?: RssDataFormat;
    fromType?: string;
    stepName?: string = 'dataFormatTransformer';
    mimeMultipart?: MimeMultipartDataFormat;
    asn1?: ASN1DataFormat | string;
    pgp?: PGPDataFormat;
    thrift?: ThriftDataFormat | string;
    json?: JsonDataFormat;
    lzf?: LZFDataFormat;
    fhirXml?: FhirXmlDataFormat;
    barcode?: BarcodeDataFormat;
    avro?: AvroDataFormat | string;
    yaml?: YAMLDataFormat;
    toType?: string;
    fhirJson?: FhirJsonDataFormat;
    any23?: Any23DataFormat | string;
    custom?: CustomDataFormat | string;
    flatpack?: FlatpackDataFormat;
    cbor?: CBORDataFormat;
    crypto?: CryptoDataFormat;
    univocityTsv?: UniVocityTsvDataFormat;
    hl7?: HL7DataFormat;
    jsonApi?: JsonApiDataFormat;
    xmlSecurity?: XMLSecurityDataFormat;
    ical?: IcalDataFormat;
    univocityFixed?: UniVocityFixedDataFormat;
    jacksonXml?: JacksonXMLDataFormat;
    grok?: GrokDataFormat;
    xstream?: XStreamDataFormat | string;
    gzipDeflater?: GzipDeflaterDataFormat;
    soap?: SoapDataFormat | string
    public constructor(init?: Partial<DataFormatTransformerDefinition>) {
        super('DataFormatTransformerDefinition')
        Object.assign(this, init)
    }
}

export class EndpointTransformerDefinition extends CamelElement {
    ref?: string;
    toType?: string;
    fromType?: string;
    scheme?: string;
    stepName?: string = 'endpointTransformer';
    uri?: string
    public constructor(init?: Partial<EndpointTransformerDefinition>) {
        super('EndpointTransformerDefinition')
        Object.assign(this, init)
    }
}

export class TransformersDefinition extends CamelElement {
    endpointTransformer?: EndpointTransformerDefinition;
    customTransformer?: CustomTransformerDefinition;
    stepName?: string = 'transformers';
    dataFormatTransformer?: DataFormatTransformerDefinition
    public constructor(init?: Partial<TransformersDefinition>) {
        super('TransformersDefinition')
        Object.assign(this, init)
    }
}

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

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

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

export class ValidatorsDefinition extends CamelElement {
    stepName?: string = 'validators';
    predicateValidator?: PredicateValidatorDefinition;
    endpointValidator?: EndpointValidatorDefinition;
    customValidator?: CustomValidatorDefinition
    public constructor(init?: Partial<ValidatorsDefinition>) {
        super('ValidatorsDefinition')
        Object.assign(this, init)
    }
}