karavan-core/src/core/model/CamelDefinition.ts - camel-karavan - Git at Google

 /**
  * 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 {
     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';
     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 {
     stepName?: string = 'route';
     routeConfigurationId?: string;
     description?: string;
     from: FromDefinition = new FromDefinition();
     streamCaching?: boolean;
     id?: string;
     precondition?: string;
     startupOrder?: number;
     routePolicy?: string;
     autoStartup?: boolean;
     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 {
     stepName?: string = 'routeTemplate';
     beans?: NamedBeanDefinition[] = [];
     from: FromDefinition = new 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)
     }
 }