type DataType = 'bool' | 'array<bool>' |
    'boolean' | 'array<boolean>' |
    'checkbox' | 'array<checkbox>' |
    'text' | 'array<text>' |
    'string' | 'array<string>' |
    'password' | 'array<password>' |
    'encrypted' | 'array<encrypted>' |
    'textarea' | 'array<textarea>' |
    'email' | 'array<email>' |
    'url' | 'array<url>' |
    'integer' | 'array<integer>' |
    'int' | 'array<int>' |
    'decimal' | 'array<decimal>' |
    'number' | 'array<number>' |
    'float' | 'array<float>' |
    'picklist' | 'array<picklist>' |
    'multi-picklist' | 'array<multi-picklist>' |
    'multipicklist' | 'array<multipicklist>' |
    'date' | 'array<date>' |
    'datetime' | 'array<datetime>' |
    'phone' | 'array<phone>' |
    'object' | 'array<object>' | string |
    'code'

type OptionsItem = {
    label: string,
    value: any
} | string | number


interface IConfig {
    title: string,
    subTitle?: string,
    description?: string,
    help?: string,
    /** @deprecated */
    icon?: string,
    defaultOrder?: number
}

type OptionalPromise<T> = Promise<T | void> | T | void

interface KeyValueObject<T> {
    [key: string]: T
}

interface IPipingType {
    label?: string,
    type?: DataType,
    language?: string,
    required?: boolean,
    help?: string,
    placeholder?: string,
    default?: any,
    sortOrder?: number,
    options?: OptionsItem[],
    properties?: IConfigMapping,
    collapsed?: boolean,
    refresh?: 'io' | 'input' | 'output' | 'none' | false | string,
    timezone?: 'No' | 'UTC' | string
}


interface IConfigMapping {
    [key: string]: IPipingType
}

interface IPipingIn {
    input?: IConfigMapping,

    dynamicInput?(input: KeyValueObject<any>, connection?: any, context?: any): OptionalPromise<IConfigMapping>,
}

interface IPipingOut {
    output?: IConfigMapping,

    dynamicOutput?(input: KeyValueObject<any>, connection?: any, context?: any): OptionalPromise<IConfigMapping>
}

interface IActionConfig extends IConfig, IPipingIn, IPipingOut {
    continuable?: boolean,
    needsConnection?: boolean,
    async?: boolean,
    type?: 'Interactive',
    bridge?: {
        actionName?: string,
        triggerName?: string,
        mapping: {
            actionInput?: {
                [key: string]: string
            },
            triggerInput?: {
                [key: string]: string
            }
        } | ((input: KeyValueObject<any>, connection?: any, context?: any) => {
            actionInput?: {
                [key: string]: string
            },
            triggerInput?: {
                [key: string]: string
            }
        })
    }
}

interface IContinuableActionConfig extends IActionConfig {
}

interface IConnectionConfig extends IConfig, IPipingIn, IPipingOut {
    type?: 'Oauth2Step' | 'Normal',

    displayInfo?(): OptionalPromise<string>
}

interface ITriggerConfig extends IConfig, IPipingIn, IPipingOut {
    type: 'Webhook' | 'Schedulable',
    needsConnection?: boolean,
    batchable?: boolean,
    cronExp?: string | ((input: KeyValueObject<any>, connection?: any, context?: any) => OptionalPromise<string>)
    webhookSuffix?(input: KeyValueObject<any>, connection?: any, context?: any): OptionalPromise<string>
}

interface IConfigModule<T extends IConfig> extends NodeModule {
    exports: T
}