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

Apache Camel Karavan Core

/**
 * 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 = 'when