@grouparoo/core/dist/models/App.d.ts

The Grouparoo Core

import { Source } from "./Source";
import { Option } from "./Option";
import { OptionHelper } from "./../modules/optionHelper";
import { AppConfigurationObject } from "../classes/codeConfig";
import { AppRefreshQuery } from "./AppRefreshQuery";
import { CommonModel } from "../classes/commonModel";
export interface SimpleAppOptions extends OptionHelper.SimpleOptions {
}
declare const STATES: readonly ["draft", "ready", "deleted"];
export declare class App extends CommonModel<App> {
    idPrefix(): string;
    name: string;
    type: string;
    locked: string;
    state: typeof STATES[number];
    appRefreshQuery: AppRefreshQuery;
    __options: Option[];
    sources: Source[];
    appOptions(): Promise<{
        [optionName: string]: {
            type: import("..").PluginOptionType;
            options?: string[];
            descriptions?: string[];
        };
    }>;
    getOptions(sourceFromEnvironment?: boolean, obfuscatePasswords?: boolean): Promise<OptionHelper.SimpleOptions>;
    setOptions(options: SimpleAppOptions, externallyValidate?: boolean): Promise<void>;
    afterSetOptions(hasChanges: boolean): Promise<void>;
    validateOptions(options?: SimpleAppOptions, externallyValidate?: boolean): Promise<void>;
    getPlugin(): Promise<{
        plugin: import("..").GrouparooPlugin;
        pluginConnection: import("..").PluginConnection;
        pluginApp: import("..").PluginApp;
    }>;
    setConnection(connection: any): Promise<void>;
    getConnection(): Promise<any>;
    connect(options?: SimpleAppOptions): Promise<any>;
    disconnect(): Promise<void>;
    test(options?: SimpleAppOptions): Promise<{
        success: boolean;
        message: string;
        error: any;
    }>;
    getParallelism(): Promise<number>;
    checkAndUpdateParallelism(direction: "incr" | "decr"): Promise<boolean>;
    parallelismKey(): string;
    apiData(): Promise<{
        id: string;
        name: string;
        icon: string;
        type: string;
        state: "ready" | "draft" | "deleted";
        locked: string;
        options: OptionHelper.SimpleOptions;
        provides: {
            source: boolean;
            destination: boolean;
        };
        pluginName: string;
        pluginApp: import("..").PluginApp;
        refreshQueryAvailable: boolean;
        createdAt: number;
        updatedAt: number;
        appRefreshQuery: {
            id: string;
            appId: string;
            refreshQuery: string;
            value: string;
            locked: string;
            state: "ready" | "draft";
            lastChangedAt: number;
            lastConfirmedAt: number;
            recurringFrequency: number;
            createdAt: number;
            updatedAt: number;
        };
    }>;
    refreshQueryAvailable(): Promise<boolean>;
    /**
     * Determine if this App can provide Source or Destination Connections
     */
    provides(): {
        source: boolean;
        destination: boolean;
    };
    getConfigId(): string;
    getConfigObject(): Promise<AppConfigurationObject>;
    _getIcon(): Promise<string>;
    static disconnect(id?: string): Promise<void>;
    static checkMaxInstances(instance: App): Promise<void>;
    static validateType(instance: App): Promise<void>;
    static updateState(instance: App): Promise<void>;
    static noUpdateIfLocked(instance: App): Promise<void>;
    static noDestroyIfLocked(instance: App): Promise<void>;
    static ensureNotInUse(instance: App): Promise<void>;
    static checkMinInstances(instance: App): Promise<void>;
    static destroyOptions(instance: App): Promise<number>;
    static destroyAppRefreshQueries(instance: App): Promise<number>;
    static removeParallelismKey(instance: App): Promise<number>;
    static invalidateCache(): Promise<void>;
}
export {};