@gangtaan/karavan-designer 3.21.2

package/dist/App.d.ts

@@ -0,0 +1,30 @@
+import * as React from "react";
+declare class ToastMessage {
+    id: string;
+    text: string;
+    title: string;
+    variant?: 'success' | 'danger' | 'warning' | 'info' | 'default';
+    constructor(title: string, text: string, variant: 'success' | 'danger' | 'warning' | 'info' | 'default');
+}
+interface Props {
+}
+interface State {
+    name: string;
+    yaml: string;
+    key: string;
+    loaded?: boolean;
+    pageId: string;
+    alerts: ToastMessage[];
+}
+declare class App extends React.Component<Props, State> {
+    state: State;
+    toast: (title: string, text: string, variant: 'success' | 'danger' | 'warning' | 'info' | 'default') => void;
+    deleteErrorMessage: (id: string) => void;
+    componentDidMount(): void;
+    save(filename: string, yaml: string, propertyOnly: boolean): void;
+    getSpinner(): JSX.Element;
+    pageNav: () => JSX.Element;
+    getPage(): JSX.Element | undefined;
+    render(): JSX.Element;
+}
+export default App;

package/dist/DesignerPage.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+
+interface Props {
+    name: string;
+    yaml: string;
+    dark: boolean;
+    onSave: (filename: string, yaml: string, propertyOnly: boolean) => void;
+}
+interface State {
+    mode: "design" | "code";
+}
+export declare class DesignerPage extends React.Component<Props, State> {
+    state: State;
+    componentDidMount(): void;
+    save(filename: string, yaml: string, propertyOnly: boolean): void;
+    download: () => void;
+    downloadImage: () => void;
+    getDesigner: () => JSX.Element;
+    getEditor: () => JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/components/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

package/dist/designer/KaravanDesigner.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+
+interface Props {
+    onSave: (filename: string, yaml: string, propertyOnly: boolean) => void;
+    onSaveCustomCode: (name: string, code: string) => void;
+    onGetCustomCode: (name: string, javaType: string) => Promise<string | undefined>;
+    filename: string;
+    yaml: string;
+    dark: boolean;
+    tab?: string;
+}
+interface State {
+    tab: string;
+    integration: Integration;
+    key: string;
+    propertyOnly: boolean;
+}
+export declare class KaravanInstance {
+    static designer: KaravanDesigner;
+    static set(designer: KaravanDesigner): void;
+    static get(): KaravanDesigner;
+    static getProps(): Props;
+}
+export declare class KaravanDesigner extends React.Component<Props, State> {
+    getIntegration: (yaml: string, filename: string) => Integration;
+    state: State;
+    componentDidMount(): void;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any) => void;
+    save: (integration: Integration, propertyOnly: boolean) => void;
+    getCode: (integration: Integration) => string;
+    getTab(title: string, tooltip: string, icon: string): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/beans/BeanCard.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { NamedBeanDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+
+interface Props {
+    bean: NamedBeanDefinition;
+    selectedStep?: NamedBeanDefinition;
+    integration: Integration;
+    selectElement: (element: NamedBeanDefinition) => void;
+    deleteElement: (element: NamedBeanDefinition) => void;
+}
+export declare class BeanCard extends React.Component<Props, any> {
+    selectElement: (evt: React.MouseEvent) => void;
+    delete: (evt: React.MouseEvent) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/beans/BeanProperties.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { NamedBeanDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+import { Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+
+interface Props {
+    integration: Integration;
+    bean?: NamedBeanDefinition;
+    dark: boolean;
+    onChange: (bean: NamedBeanDefinition) => void;
+    onClone: (bean: NamedBeanDefinition) => void;
+}
+interface State {
+    bean?: NamedBeanDefinition;
+    properties: Map<string, [string, string, boolean]>;
+    key: string;
+    showKubernetesSelector: boolean;
+    kubernetesSelectorUuid?: string;
+    kubernetesSelectorProperty?: string;
+}
+export declare class BeanProperties extends React.Component<Props, State> {
+    preparePropertiesMap: (properties: any) => Map<string, [
+        string,
+        string,
+        boolean
+    ]>;
+    state: State;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any) => void;
+    setBean: (bean?: NamedBeanDefinition) => void;
+    beanChanged: (fieldId: string, value: string) => void;
+    propertyChanged: (uuid: string, key: string, value: string, showPassword: boolean) => void;
+    propertyDeleted: (uuid: string) => void;
+    selectKubernetes: (value: string) => void;
+    openKubernetesSelector: (uuid: string, propertyName: string) => void;
+    closeKubernetesSelector: () => void;
+    getKubernetesSelectorModal(): JSX.Element;
+    cloneBean: () => void;
+    getLabelIcon: (displayName: string, description: string) => JSX.Element;
+    getBeanForm(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/beans/BeansDesigner.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { NamedBeanDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+import { Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+
+interface Props {
+    onSave?: (integration: Integration, propertyOnly: boolean) => void;
+    integration: Integration;
+    dark: boolean;
+}
+interface State {
+    integration: Integration;
+    showDeleteConfirmation: boolean;
+    selectedBean?: NamedBeanDefinition;
+    key: string;
+    propertyOnly: boolean;
+}
+export declare class BeansDesigner extends React.Component<Props, State> {
+    state: State;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any) => void;
+    showDeleteConfirmation: (bean: NamedBeanDefinition) => void;
+    onIntegrationUpdate: (i: Integration) => void;
+    deleteBean: () => void;
+    changeBean: (bean: NamedBeanDefinition) => void;
+    getDeleteConfirmation(): JSX.Element;
+    selectBean: (bean?: NamedBeanDefinition) => void;
+    unselectBean: (evt: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    createBean: () => void;
+    getPropertiesPanel(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/rest/RestCard.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { CamelElement, Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { RestDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+
+interface Props {
+    rest: RestDefinition;
+    selectedStep?: CamelElement;
+    integration: Integration;
+    selectMethod: (element: CamelElement) => void;
+    selectElement: (element: CamelElement) => void;
+    deleteElement: (element: CamelElement) => void;
+}
+export declare class RestCard extends React.Component<Props, any> {
+    selectElement: (evt: React.MouseEvent) => void;
+    selectMethod: (evt: React.MouseEvent) => void;
+    delete: (evt: React.MouseEvent) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/rest/RestConfigurationCard.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { CamelElement, Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { RestConfigurationDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+
+interface Props {
+    restConfig: RestConfigurationDefinition;
+    selectedRestConfig?: CamelElement;
+    integration: Integration;
+    selectElement: (element: CamelElement) => void;
+    deleteElement: (element: CamelElement) => void;
+}
+interface State {
+    restConfig: RestConfigurationDefinition;
+    expanded: boolean;
+}
+export declare class RestConfigurationCard extends React.Component<Props, State> {
+    state: State;
+    selectElement: (evt: React.MouseEvent) => void;
+    delete: (evt: React.MouseEvent) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/rest/RestDesigner.d.ts

@@ -0,0 +1,43 @@
+import { default as React } from 'react';
+import { Integration, CamelElement } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { RouteToCreate } from '../utils/CamelUi';
+import { RestContextRefDefinition, RestDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+import { DslMetaModel } from '../utils/DslMetaModel';
+
+interface Props {
+    onSave?: (integration: Integration, propertyOnly: boolean) => void;
+    integration: Integration;
+    dark: boolean;
+}
+interface State {
+    integration: Integration;
+    selectedStep?: CamelElement;
+    key: string;
+    showSelector: boolean;
+    showDeleteConfirmation: boolean;
+    propertyOnly: boolean;
+}
+export declare class RestDesigner extends React.Component<Props, State> {
+    state: State;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any) => void;
+    onIntegrationUpdate: (i: Integration) => void;
+    selectElement: (element: CamelElement) => void;
+    onPropertyUpdate: (element: CamelElement, newRoute?: RouteToCreate) => void;
+    unselectElement: (evt: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    addRest: (rest: RestDefinition) => void;
+    createRest: () => void;
+    createRestConfiguration: () => void;
+    showDeleteConfirmation: (element: CamelElement) => void;
+    deleteElement: () => void;
+    getDeleteConfirmation(): JSX.Element;
+    closeMethodSelector: () => void;
+    onMethodSelect: (method: DslMetaModel) => void;
+    cloneRest: (rest: CamelElement) => void;
+    selectMethod: (element: CamelElement) => void;
+    getSelectorModal(): JSX.Element;
+    getRestConfigurationCard(config: RestContextRefDefinition): JSX.Element;
+    getRestCards(data: RestDefinition[]): JSX.Element;
+    getPropertiesPanel(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/rest/RestMethodCard.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { CamelElement, Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+
+interface Props<T> {
+    method: T;
+    selectedStep?: CamelElement;
+    integration: Integration;
+    selectElement: (element: CamelElement) => void;
+    deleteElement: (element: CamelElement) => void;
+}
+interface State<T> {
+    method: T;
+    expanded: boolean;
+}
+export declare class RestMethodCard extends React.Component<Props<any>, State<any>> {
+    state: State<any>;
+    selectElement: (evt: React.MouseEvent) => void;
+    delete: (evt: React.MouseEvent) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/rest/RestMethodSelector.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { DslMetaModel } from '../utils/DslMetaModel';
+
+interface Props {
+    onMethodSelect: (method: DslMetaModel) => void;
+    dark: boolean;
+}
+interface State {
+}
+export declare class RestMethodSelector extends React.Component<Props, State> {
+    state: State;
+    selectTab: (evt: React.MouseEvent<HTMLElement, MouseEvent>, eventKey: string | number) => void;
+    selectMethod: (evt: React.MouseEvent, method: any) => void;
+    getCard(dsl: DslMetaModel, index: number): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/route/DslConnections.d.ts

@@ -0,0 +1,40 @@
+import { default as React } from 'react';
+import { Integration, CamelElement } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { DslPosition } from '../utils/EventBus';
+import { Subscription } from 'rxjs';
+
+interface Props {
+    integration: Integration;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+}
+interface State {
+    integration: Integration;
+    steps: Map<string, DslPosition>;
+}
+export declare class DslConnections extends React.Component<Props, State> {
+    state: State;
+    sub?: Subscription;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    setPosition(evt: DslPosition): void;
+    getIncomings(): [string, number][];
+    getIncoming(data: [string, number]): JSX.Element | undefined;
+    hasOverlap(data: [string, number][]): boolean;
+    addGap(data: [string, number][]): [string, number][];
+    getOutgoings(): [string, number][];
+    getOutgoing(data: [string, number]): JSX.Element | undefined;
+    getInternals(): [string, number, boolean][];
+    getInternalLines(data: [string, number, boolean]): any[] | JSX.Element | undefined;
+    getInternalLine(uri: string, key: string, className: string, fromX: number, fromY: number, r: number, i: number): JSX.Element | undefined;
+    getInternalPath(key: string, className: string, startX: number, startY: number, pointX1: number, pointY1: number, pointX2: number, pointY2: number, pointLX: number, pointLY: number, pointX3: number, pointY3: number, pointX4: number, pointY4: number, endX: number, endY: number): JSX.Element;
+    getCircle(pos: DslPosition): JSX.Element;
+    hasSteps: (step: CamelElement) => boolean;
+    getPreviousStep(pos: DslPosition): DslPosition;
+    getArrow(pos: DslPosition): JSX.Element | undefined;
+    getSvg(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/route/DslElement.d.ts

@@ -0,0 +1,63 @@
+import { default as React } from 'react';
+import { CamelElement, Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { ChildElement } from '@gangtaan/karavan-core/lib/api/CamelDefinitionApiExt';
+
+interface Props {
+    integration: Integration;
+    step: CamelElement;
+    parent: CamelElement | undefined;
+    deleteElement: any;
+    selectElement: any;
+    openSelector: (parentId: string | undefined, parentDsl: string | undefined, showSteps: boolean, position?: number | undefined) => void;
+    moveElement: (source: string, target: string, asChild: boolean) => void;
+    selectedUuid: string[];
+    inSteps: boolean;
+    position: number;
+}
+interface State {
+    showSelector: boolean;
+    showMoveConfirmation: boolean;
+    moveElements: [string | undefined, string | undefined];
+    tabIndex: string | number;
+    isDragging: boolean;
+    isDraggedOver: boolean;
+}
+export declare class DslElement extends React.Component<Props, State> {
+    state: State;
+    openSelector: (evt: React.MouseEvent, showSteps?: boolean, isInsert?: boolean) => void;
+    closeDslSelector: () => void;
+    delete: (evt: React.MouseEvent) => void;
+    selectElement: (evt: React.MouseEvent) => void;
+    dragElement: (event: React.DragEvent<HTMLDivElement>, element: CamelElement) => void;
+    confirmMove: (asChild: boolean) => void;
+    cancelMove: () => void;
+    isSelected: () => boolean;
+    hasBorder: () => boolean;
+    isNotDraggable: () => boolean;
+    isWide: () => boolean;
+    isAddStepButtonLeft: () => boolean;
+    isHorizontal: () => boolean;
+    isRoot: () => boolean;
+    isInStepWithChildren: () => boolean;
+    getChildrenInfo: (step: CamelElement) => [boolean, number, boolean, number, number];
+    hasWideChildrenElement: () => boolean;
+    hasBorderOverSteps: (step: CamelElement) => boolean;
+    getHeaderStyle: () => React.CSSProperties;
+    sendPosition: (el: HTMLDivElement | null, isSelected: boolean) => void;
+    getHeader: () => JSX.Element;
+    getHeaderTextWithTooltip: (step: CamelElement) => JSX.Element;
+    getHeaderWithTooltip: (tooltip: string | undefined) => JSX.Element;
+    getHeaderTooltip: () => string | undefined;
+    getElementHeader: () => JSX.Element;
+    getChildrenStyle: () => React.CSSProperties;
+    getChildrenElementsStyle: (child: ChildElement, notOnlySteps: boolean) => React.CSSProperties;
+    getChildElements: () => JSX.Element;
+    getChildDslElements: (child: ChildElement, index: number, notOnlySteps: boolean) => JSX.Element | undefined;
+    getAddStepButton(): JSX.Element;
+    getAddElementButton(): JSX.Element;
+    getInsertElementButton(): JSX.Element;
+    getDeleteButton(): JSX.Element;
+    getMoveConfirmation(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/route/DslProperties.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { ExpressionDefinition, DataFormatDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+import { Integration, CamelElement } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { RouteToCreate } from '../utils/CamelUi';
+import { PropertyMeta } from '@gangtaan/karavan-core/lib/model/CamelMetadata';
+
+interface Props {
+    integration: Integration;
+    step?: CamelElement;
+    onIntegrationUpdate?: any;
+    onPropertyUpdate?: (element: CamelElement, newRoute?: RouteToCreate) => void;
+    onClone?: (element: CamelElement) => void;
+    isRouteDesigner: boolean;
+    dark: boolean;
+}
+interface State {
+    step?: CamelElement;
+    selectStatus: Map<string, boolean>;
+    isShowAdvanced: boolean;
+    isDescriptionExpanded?: boolean;
+}
+export declare class DslProperties extends React.Component<Props, State> {
+    state: State;
+    propertyChanged: (fieldId: string, value: string | number | boolean | any, newRoute?: RouteToCreate) => void;
+    dataFormatChanged: (value: DataFormatDefinition) => void;
+    expressionChanged: (propertyName: string, exp: ExpressionDefinition) => void;
+    parametersChanged: (parameter: string, value: string | number | boolean | any, pathParameter?: boolean, newRoute?: RouteToCreate) => void;
+    cloneElement: () => void;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any) => void;
+    setStep: (step?: CamelElement) => void;
+    getRouteHeader: () => JSX.Element;
+    getClonableElementHeader: () => JSX.Element;
+    getComponentHeader: () => JSX.Element;
+    getProperties: () => PropertyMeta[];
+    getPropertyFields: (properties: PropertyMeta[]) => JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/route/DslSelector.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { DslMetaModel } from '../utils/DslMetaModel';
+
+interface Props {
+    onDslSelect: (dsl: DslMetaModel, parentId: string, position?: number | undefined) => void;
+    onClose?: () => void;
+    parentId: string;
+    parentDsl?: string;
+    showSteps: boolean;
+    dark: boolean;
+    isOpen: boolean;
+    position?: number;
+    tabIndex?: string | number;
+}
+interface State {
+    tabIndex: string | number;
+    filter: string;
+}
+export declare class DslSelector extends React.Component<Props, State> {
+    getDefaultTabIndex: () => string;
+    state: State;
+    selectTab: (evt: React.MouseEvent<HTMLElement, MouseEvent>, eventKey: string | number) => void;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any) => void;
+    selectDsl: (evt: React.MouseEvent, dsl: any) => void;
+    searchInput: () => JSX.Element;
+    getCard(dsl: DslMetaModel, index: number): JSX.Element;
+    close: () => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/route/RouteDesigner.d.ts

@@ -0,0 +1,48 @@
+import { default as React } from 'react';
+import { CamelElement, Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { RouteDesignerLogic } from './RouteDesignerLogic';
+
+interface Props {
+    onSave?: (integration: Integration, propertyOnly: boolean) => void;
+    integration: Integration;
+    dark: boolean;
+}
+export interface RouteDesignerState {
+    logic: RouteDesignerLogic;
+    integration: Integration;
+    selectedStep?: CamelElement;
+    showSelector: boolean;
+    showDeleteConfirmation: boolean;
+    deleteMessage: string;
+    parentId: string;
+    parentDsl?: string;
+    selectedPosition?: number;
+    showSteps: boolean;
+    selectedUuids: string[];
+    key: string;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    clipboardSteps: CamelElement[];
+    shiftKeyPressed?: boolean;
+    ref?: any;
+    printerRef?: any;
+    propertyOnly: boolean;
+    selectorTabIndex?: string | number;
+}
+export declare class RouteDesigner extends React.Component<Props, RouteDesignerState> {
+    state: RouteDesignerState;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    handleResize: (event: any) => void;
+    handleKeyDown: (event: KeyboardEvent) => void;
+    handleKeyUp: (event: KeyboardEvent) => void;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<RouteDesignerState>, snapshot?: any) => void;
+    getSelectorModal(): JSX.Element;
+    getDeleteConfirmation(): JSX.Element;
+    getPropertiesPanel(): JSX.Element;
+    getGraph(): JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/route/RouteDesignerLogic.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+import { DslMetaModel } from '../utils/DslMetaModel';
+import { CamelElement, Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+import { Command } from '../utils/EventBus';
+import { RouteToCreate } from '../utils/CamelUi';
+import { RouteDesigner, RouteDesignerState } from './RouteDesigner';
+import { Subscription } from 'rxjs';
+
+export declare class RouteDesignerLogic {
+    routeDesigner: RouteDesigner;
+    commandSub?: Subscription;
+    constructor(routeDesigner: RouteDesigner);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    handleResize: (event: any) => void;
+    handleKeyDown: (event: KeyboardEvent) => void;
+    handleKeyUp: (event: KeyboardEvent) => void;
+    componentDidUpdate: (prevState: Readonly<RouteDesignerState>, snapshot?: any) => void;
+    copyToClipboard: () => void;
+    pasteFromClipboard: () => void;
+    onCommand: (command: Command) => void;
+    onPropertyUpdate: (element: CamelElement, newRoute?: RouteToCreate) => void;
+    showDeleteConfirmation: (id: string) => void;
+    deleteElement: () => void;
+    selectElement: (element: CamelElement) => void;
+    unselectElement: (evt: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    openSelector: (parentId: string | undefined, parentDsl: string | undefined, showSteps?: boolean, position?: number | undefined, selectorTabIndex?: string | number) => void;
+    closeDslSelector: () => void;
+    onDslSelect: (dsl: DslMetaModel, parentId: string, position?: number | undefined) => void;
+    setDslDefaults(step: CamelElement): CamelElement;
+    createRouteConfiguration: () => void;
+    addStep: (step: CamelElement, parentId: string, position?: number | undefined) => void;
+    onIntegrationUpdate: (i: Integration) => void;
+    moveElement: (source: string, target: string, asChild: boolean) => void;
+    onResizePage(el: HTMLDivElement | null): void;
+    downloadIntegrationImage(dataUrl: string): void;
+    integrationImageDownloadFilter: (node: HTMLElement) => boolean;
+    integrationImageDownload(): void;
+}

package/dist/designer/route/property/ComponentParameterField.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { ComponentProperty } from '@gangtaan/karavan-core/lib/model/ComponentModels';
+import { RouteToCreate } from '../../utils/CamelUi';
+import { CamelElement, Integration } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+
+interface Props {
+    property: ComponentProperty;
+    integration: Integration;
+    element?: CamelElement;
+    value: any;
+    onParameterChange?: (parameter: string, value: string | number | boolean | any, pathParameter?: boolean, newRoute?: RouteToCreate) => void;
+}
+interface State {
+    selectStatus: Map<string, boolean>;
+    showEditor: boolean;
+    showPassword: boolean;
+    showKubernetesSelector: boolean;
+    kubernetesSelectorProperty?: string;
+    ref: any;
+    id: string;
+}
+export declare class ComponentParameterField extends React.Component<Props, State> {
+    state: State;
+    parametersChanged: (parameter: string, value: string | number | boolean | any, pathParameter?: boolean, newRoute?: RouteToCreate) => void;
+    openSelect: (propertyName: string, isExpanded: boolean) => void;
+    isSelectOpen: (propertyName: string) => boolean;
+    getSelectBean: (property: ComponentProperty, value: any) => JSX.Element;
+    canBeInternalUri: (property: ComponentProperty) => boolean;
+    getInternalComponentName: (property: ComponentProperty) => string;
+    getInternalUriSelect: (property: ComponentProperty, value: any) => JSX.Element;
+    selectKubernetes: (value: string) => void;
+    openKubernetesSelector: (propertyName: string) => void;
+    closeKubernetesSelector: () => void;
+    getKubernetesSelectorModal(): JSX.Element;
+    getStringInput(property: ComponentProperty, value: any): JSX.Element;
+    getTextInput: (property: ComponentProperty, value: any) => JSX.Element;
+    getSelect: (property: ComponentProperty, value: any) => JSX.Element;
+    getSwitch: (property: ComponentProperty, value: any) => JSX.Element;
+    render(): JSX.Element;
+}
+export {};

package/dist/designer/route/property/DataFormatField.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { PropertyMeta } from '@gangtaan/karavan-core/lib/model/CamelMetadata';
+import { DataFormatDefinition } from '@gangtaan/karavan-core/lib/model/CamelDefinition';
+import { Integration, CamelElement } from '@gangtaan/karavan-core/lib/model/IntegrationDefinition';
+
+interface Props {
+    dslName: string;
+    value: CamelElement;
+    onDataFormatChange?: (value: DataFormatDefinition) => void;
+    integration: Integration;
+    dark: boolean;
+}
+interface State {
+    selectIsOpen: boolean;
+    dataFormat: string;
+    isShowAdvanced: boolean;
+}
+export declare class DataFormatField extends React.Component<Props, State> {
+    state: State;
+    componentDidMount(): void;
+    componentDidUpdate: (prevProps: Readonly<Props>, prevState: Readonly<State>, snapshot?: any) => void;
+    openSelect: () => void;
+    dataFormatChanged: (dataFormat: string, value?: CamelElement) => void;
+    propertyChanged: (fieldId: string, value: string | number | boolean | any) => void;
+    getDataFormatValue: () => CamelElement;
+    getPropertyFields: (value: any, properties: PropertyMeta[]) => JSX.Element;
+    render(): JSX.Element;
+}
+export {};