@grouparoo/core/dist/actions/destinations.d.ts

The Grouparoo Core

import { ParamsFrom } from "actionhero";
import { AuthenticatedAction } from "../classes/actions/authenticatedAction";
import { App } from "../models/App";
import { PluginConnection } from "../classes/plugin";
import { OptionHelper } from "../modules/optionHelper";
import { AsyncReturnType } from "type-fest";
import { APIData } from "../modules/apiData";
import { ActionPermission } from "../models/Permission";
export declare class DestinationsList extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly limit: {
            readonly required: true;
            readonly default: 100;
            readonly formatter: typeof APIData.ensureNumber;
        };
        readonly offset: {
            readonly required: true;
            readonly default: 0;
            readonly formatter: typeof APIData.ensureNumber;
        };
        readonly state: {
            readonly required: false;
        };
        readonly modelId: {
            readonly required: false;
        };
        readonly order: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureArray;
            readonly default: readonly [readonly ["name", "desc"], readonly ["createdAt", "desc"]];
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationsList>;
    }): Promise<{
        total: number;
        destinations: {
            id: string;
            name: string;
            type: string;
            state: "ready" | "draft" | "deleted";
            locked: string;
            syncMode: "sync" | "additive" | "enrich";
            syncModes: {
                key: "sync" | "additive" | "enrich";
                displayName: string;
                description: string;
                operations: import("../models/Destination").DestinationSyncOperations;
            }[];
            collection: "none" | "group" | "model";
            app: {
                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("../classes/plugin").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;
                };
            };
            modelId: string;
            modelName: string;
            mapping: import("../modules/mappingHelper").MappingHelper.Mappings;
            options: OptionHelper.SimpleOptions;
            connection: PluginConnection;
            group: {
                id: string;
                name: string;
                modelId: string;
                modelName: string;
                rules: import("../models/Group").GroupRuleWithKey[];
                matchType: "all" | "any";
                state: "ready" | "draft" | "deleted" | "initializing" | "updating";
                locked: string;
                recordsCount: number;
                createdAt: number;
                updatedAt: number;
                nextCalculatedAt: number;
                calculatedAt: number;
            };
            destinationGroupMemberships: import("../models/Destination").SimpleDestinationGroupMembership[];
            createdAt: number;
            updatedAt: number;
            exportTotals: {
                failed: number;
                canceled: number;
                complete: number;
                pending: number;
                draft: number;
                processing: number;
            };
        }[];
    }>;
}
export declare class DestinationConnectionApps extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    runWithinTransaction(): Promise<{
        connectionApps: {
            app: AsyncReturnType<App["apiData"]>;
            connection: PluginConnection;
        }[];
        environmentVariableOptions: string[];
    }>;
}
export declare class DestinationCreate extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly name: {
            readonly required: false;
        };
        readonly type: {
            readonly required: true;
        };
        readonly modelId: {
            readonly required: true;
        };
        readonly state: {
            readonly required: false;
        };
        readonly appId: {
            readonly required: true;
        };
        readonly options: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
        readonly mapping: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
            readonly default: {};
        };
        readonly syncMode: {
            readonly required: false;
        };
        readonly destinationGroupMemberships: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationCreate>;
    }): Promise<{
        destination: {
            id: string;
            name: string;
            type: string;
            state: "ready" | "draft" | "deleted";
            locked: string;
            syncMode: "sync" | "additive" | "enrich";
            syncModes: {
                key: "sync" | "additive" | "enrich";
                displayName: string;
                description: string;
                operations: import("../models/Destination").DestinationSyncOperations;
            }[];
            collection: "none" | "group" | "model";
            app: {
                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("../classes/plugin").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;
                };
            };
            modelId: string;
            modelName: string;
            mapping: import("../modules/mappingHelper").MappingHelper.Mappings;
            options: OptionHelper.SimpleOptions;
            connection: PluginConnection;
            group: {
                id: string;
                name: string;
                modelId: string;
                modelName: string;
                rules: import("../models/Group").GroupRuleWithKey[];
                matchType: "all" | "any";
                state: "ready" | "draft" | "deleted" | "initializing" | "updating";
                locked: string;
                recordsCount: number;
                createdAt: number;
                updatedAt: number;
                nextCalculatedAt: number;
                calculatedAt: number;
            };
            destinationGroupMemberships: import("../models/Destination").SimpleDestinationGroupMembership[];
            createdAt: number;
            updatedAt: number;
            exportTotals: {
                failed: number;
                canceled: number;
                complete: number;
                pending: number;
                draft: number;
                processing: number;
            };
        };
    }>;
}
export declare class DestinationEdit extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
        readonly name: {
            readonly required: false;
        };
        readonly state: {
            readonly required: false;
        };
        readonly options: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
        readonly mapping: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
        readonly syncMode: {
            readonly required: false;
        };
        readonly destinationGroupMemberships: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
        readonly groupId: {
            readonly required: false;
        };
        readonly collection: {
            readonly required: false;
            readonly formatter: (p: unknown) => "none" | "group" | "model";
        };
        readonly triggerExport: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureBoolean;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationEdit>;
    }): Promise<{
        destination: {
            id: string;
            name: string;
            type: string;
            state: "ready" | "draft" | "deleted";
            locked: string;
            syncMode: "sync" | "additive" | "enrich";
            syncModes: {
                key: "sync" | "additive" | "enrich";
                displayName: string;
                description: string;
                operations: import("../models/Destination").DestinationSyncOperations;
            }[];
            collection: "none" | "group" | "model";
            app: {
                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("../classes/plugin").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;
                };
            };
            modelId: string;
            modelName: string;
            mapping: import("../modules/mappingHelper").MappingHelper.Mappings;
            options: OptionHelper.SimpleOptions;
            connection: PluginConnection;
            group: {
                id: string;
                name: string;
                modelId: string;
                modelName: string;
                rules: import("../models/Group").GroupRuleWithKey[];
                matchType: "all" | "any";
                state: "ready" | "draft" | "deleted" | "initializing" | "updating";
                locked: string;
                recordsCount: number;
                createdAt: number;
                updatedAt: number;
                nextCalculatedAt: number;
                calculatedAt: number;
            };
            destinationGroupMemberships: import("../models/Destination").SimpleDestinationGroupMembership[];
            createdAt: number;
            updatedAt: number;
            exportTotals: {
                failed: number;
                canceled: number;
                complete: number;
                pending: number;
                draft: number;
                processing: number;
            };
        };
        oldRun: {
            id: string;
            creatorId: string;
            creatorName: string;
            creatorType: "group" | "task" | "schedule" | "property" | "grouparooModel" | "teamMember";
            state: "stopped" | "running" | "complete" | "draft";
            percentComplete: number;
            importsCreated: number;
            recordsCreated: number;
            recordsImported: number;
            error: string;
            highWaterMark: import("../models/Run").HighWaterMark;
            sourceOffset: string | number;
            memberLimit: number;
            memberOffset: number;
            method: string;
            destinationId: string;
            createdAt: number;
            updatedAt: number;
            completedAt: number;
        };
        newRun: {
            id: string;
            creatorId: string;
            creatorName: string;
            creatorType: "group" | "task" | "schedule" | "property" | "grouparooModel" | "teamMember";
            state: "stopped" | "running" | "complete" | "draft";
            percentComplete: number;
            importsCreated: number;
            recordsCreated: number;
            recordsImported: number;
            error: string;
            highWaterMark: import("../models/Run").HighWaterMark;
            sourceOffset: string | number;
            memberLimit: number;
            memberOffset: number;
            method: string;
            destinationId: string;
            createdAt: number;
            updatedAt: number;
            completedAt: number;
        };
    }>;
}
export declare class DestinationConnectionOptions extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
        readonly options: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationConnectionOptions>;
    }): Promise<{
        options: import("../classes/plugin").DestinationOptionsMethodResponse;
    }>;
}
export declare class DestinationMappingOptions extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationMappingOptions>;
    }): Promise<{
        options: import("../classes/plugin").DestinationMappingOptionsMethodResponse;
        destinationTypeConversions: Record<string, any>;
    }>;
}
export declare class DestinationExportArrayProperties extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationExportArrayProperties>;
    }): Promise<{
        exportArrayProperties: import("../classes/plugin").ExportArrayPropertiesMethodResponse;
    }>;
}
export declare class DestinationView extends AuthenticatedAction {
    name: string;
    description: string;
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationView>;
    }): Promise<{
        destination: {
            id: string;
            name: string;
            type: string;
            state: "ready" | "draft" | "deleted";
            locked: string;
            syncMode: "sync" | "additive" | "enrich";
            syncModes: {
                key: "sync" | "additive" | "enrich";
                displayName: string;
                description: string;
                operations: import("../models/Destination").DestinationSyncOperations;
            }[];
            collection: "none" | "group" | "model";
            app: {
                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("../classes/plugin").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;
                };
            };
            modelId: string;
            modelName: string;
            mapping: import("../modules/mappingHelper").MappingHelper.Mappings;
            options: OptionHelper.SimpleOptions;
            connection: PluginConnection;
            group: {
                id: string;
                name: string;
                modelId: string;
                modelName: string;
                rules: import("../models/Group").GroupRuleWithKey[];
                matchType: "all" | "any";
                state: "ready" | "draft" | "deleted" | "initializing" | "updating";
                locked: string;
                recordsCount: number;
                createdAt: number;
                updatedAt: number;
                nextCalculatedAt: number;
                calculatedAt: number;
            };
            destinationGroupMemberships: import("../models/Destination").SimpleDestinationGroupMembership[];
            createdAt: number;
            updatedAt: number;
            exportTotals: {
                failed: number;
                canceled: number;
                complete: number;
                pending: number;
                draft: number;
                processing: number;
            };
        };
    }>;
}
export declare class DestinationExport extends AuthenticatedAction {
    name: string;
    description: string;
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
        readonly recordId: {
            readonly required: false;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationExport>;
    }): Promise<{
        success: boolean;
    }>;
}
export declare class DestinationRecordPreview extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
        readonly collection: {
            readonly required: false;
        };
        readonly groupId: {
            readonly required: false;
        };
        readonly modelId: {
            readonly required: false;
        };
        readonly recordId: {
            readonly required: false;
        };
        readonly mapping: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
        readonly destinationGroupMemberships: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureObject;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationRecordPreview>;
    }): Promise<{
        record: {
            id: string;
            state: "pending" | "ready" | "draft" | "deleted";
            modelId: string;
            modelName: string;
            groupIds: string[];
            invalid: boolean;
            properties: import("../modules/ops/record").RecordPropertyType;
            createdAt: number;
            updatedAt: number;
        } & {
            properties: Record<string, any>;
            groupNames: string[];
        };
        groups: {
            id: string;
            name: string;
            modelId: string;
            modelName: string;
            rules: import("../models/Group").GroupRuleWithKey[];
            matchType: "all" | "any";
            state: "ready" | "draft" | "deleted" | "initializing" | "updating";
            locked: string;
            recordsCount: number;
            createdAt: number;
            updatedAt: number;
            nextCalculatedAt: number;
            calculatedAt: number;
        }[];
        destinations: {
            id: string;
            name: string;
            type: string;
            state: "ready" | "draft" | "deleted";
            locked: string;
            syncMode: "sync" | "additive" | "enrich";
            syncModes: {
                key: "sync" | "additive" | "enrich";
                displayName: string;
                description: string;
                operations: import("../models/Destination").DestinationSyncOperations;
            }[];
            collection: "none" | "group" | "model";
            app: {
                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("../classes/plugin").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;
                };
            };
            modelId: string;
            modelName: string;
            mapping: import("../modules/mappingHelper").MappingHelper.Mappings;
            options: OptionHelper.SimpleOptions;
            connection: PluginConnection;
            group: {
                id: string;
                name: string;
                modelId: string;
                modelName: string;
                rules: import("../models/Group").GroupRuleWithKey[];
                matchType: "all" | "any";
                state: "ready" | "draft" | "deleted" | "initializing" | "updating";
                locked: string;
                recordsCount: number;
                createdAt: number;
                updatedAt: number;
                nextCalculatedAt: number;
                calculatedAt: number;
            };
            destinationGroupMemberships: import("../models/Destination").SimpleDestinationGroupMembership[];
            createdAt: number;
            updatedAt: number;
            exportTotals: {
                failed: number;
                canceled: number;
                complete: number;
                pending: number;
                draft: number;
                processing: number;
            };
        }[];
    }>;
}
export declare class DestinationDestroy extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
        readonly force: {
            readonly required: true;
            readonly default: false;
            readonly formatter: (p: string | boolean) => boolean;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<DestinationDestroy>;
    }): Promise<{
        success: boolean;
    }>;
}