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

The Grouparoo Core

import { DestinationConfigurationObject } from "../classes/codeConfig";
import { MappingHelper } from "./../modules/mappingHelper";
import { DestinationOps } from "./../modules/ops/destination";
import { OptionHelper } from "./../modules/optionHelper";
import { App } from "./App";
import { GrouparooRecord } from "./../models/GrouparooRecord";
import { DestinationGroupMembership } from "./DestinationGroupMembership";
import { Export } from "./Export";
import { ExportProcessor } from "./ExportProcessor";
import { Group } from "./Group";
import { Mapping } from "./Mapping";
import { Option } from "./Option";
import { GrouparooModel } from "./GrouparooModel";
import { CommonModel } from "../classes/commonModel";
export interface DestinationMapping extends MappingHelper.Mappings {
}
export interface SimpleDestinationGroupMembership {
    remoteKey: string;
    groupId: string;
    groupName: string;
}
export interface SimpleDestinationOptions extends OptionHelper.SimpleOptions {
}
declare const SYNC_MODES: readonly ["sync", "additive", "enrich"];
export declare type DestinationSyncMode = typeof SYNC_MODES[number];
declare const DESTINATION_COLLECTIONS: readonly ["none", "group", "model"];
export declare type DestinationCollection = typeof DESTINATION_COLLECTIONS[number];
export interface DestinationSyncOperations {
    create: boolean;
    update: boolean;
    delete: boolean;
}
export declare const DestinationSyncModeData: Record<DestinationSyncMode, {
    key: DestinationSyncMode;
    displayName: string;
    description: string;
    operations: DestinationSyncOperations;
}>;
declare const STATES: readonly ["draft", "ready", "deleted"];
export declare class Destination extends CommonModel<Destination> {
    idPrefix(): string;
    appId: string;
    name: string;
    type: string;
    locked: string;
    state: typeof STATES[number];
    groupId: string;
    syncMode: DestinationSyncMode;
    collection: DestinationCollection;
    modelId: string;
    app: App;
    destinationGroupMemberships: DestinationGroupMembership[];
    group: Group;
    mappings: Mapping[];
    __options: Option[];
    exports: Export[];
    model: GrouparooModel;
    apiData(includeApp?: boolean, includeGroup?: boolean): Promise<{
        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: 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("..").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: MappingHelper.Mappings;
        options: OptionHelper.SimpleOptions;
        connection: import("..").PluginConnection;
        group: {
            id: string;
            name: string;
            modelId: string;
            modelName: string;
            rules: import("./Group").GroupRuleWithKey[];
            matchType: "all" | "any";
            state: "ready" | "draft" | "deleted" | "initializing" | "updating";
            locked: string;
            recordsCount: number;
            createdAt: number;
            updatedAt: number;
            nextCalculatedAt: number;
            calculatedAt: number;
        };
        destinationGroupMemberships: SimpleDestinationGroupMembership[];
        createdAt: number;
        updatedAt: number;
        exportTotals: {
            failed: number;
            canceled: number;
            complete: number;
            pending: number;
            draft: number;
            processing: number;
        };
    }>;
    getExportTotals(): Promise<{
        failed: number;
        canceled: number;
        complete: number;
        pending: number;
        draft: number;
        processing: number;
    }>;
    getMapping(): Promise<MappingHelper.Mappings>;
    setMapping(mappings: DestinationMapping, externallyValidate?: boolean, saveCache?: boolean): Promise<void>;
    getOptions(sourceFromEnvironment?: boolean): Promise<OptionHelper.SimpleOptions>;
    setOptions(options: SimpleDestinationOptions, externallyValidate?: boolean): Promise<void>;
    afterSetOptions(hasChanges: boolean): Promise<import("./Run").Run>;
    getExportArrayProperties(): Promise<import("..").ExportArrayPropertiesMethodResponse>;
    getDestinationGroupMemberships(): Promise<SimpleDestinationGroupMembership[]>;
    setDestinationGroupMemberships(newDestinationGroupMemberships: {
        [groupId: string]: string;
    }): Promise<SimpleDestinationGroupMembership[]>;
    validateOptions(options?: SimpleDestinationOptions, externallyValidate?: boolean): Promise<void>;
    getPlugin(): Promise<{
        plugin: import("..").GrouparooPlugin;
        pluginConnection: import("..").PluginConnection;
        pluginApp: import("..").PluginApp;
    }>;
    exportMembers(): Promise<import("./Run").Run>;
    updateTracking(collection: Destination["collection"], collectionId?: string): Promise<{
        oldRun: import("./Run").Run;
        newRun: import("./Run").Run;
    }>;
    getSupportedSyncModes(): Promise<{
        supportedModes: ("sync" | "additive" | "enrich")[];
        defaultMode: "sync" | "additive" | "enrich";
    }>;
    getSyncMode(): Promise<"sync" | "additive" | "enrich">;
    validateSyncMode(): Promise<void>;
    validateMappings(mappings: {
        [key: string]: string;
    }, saveCache?: boolean): Promise<void>;
    parameterizedOptions(): Promise<SimpleDestinationOptions>;
    destinationConnectionOptions(destinationOptions?: SimpleDestinationOptions): Promise<import("..").DestinationOptionsMethodResponse>;
    destinationMappingOptions(cached?: boolean, saveCache?: boolean): Promise<import("..").DestinationMappingOptionsMethodResponse>;
    recordPreview(record: GrouparooRecord, mapping: MappingHelper.Mappings, destinationGroupMemberships: {
        [groupId: string]: string;
    }): Promise<{
        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[];
    }>;
    checkRecordWillBeExported(record: GrouparooRecord): Promise<boolean>;
    exportRecord(record: GrouparooRecord, sync?: boolean, force?: boolean, saveExports?: boolean, toDelete?: boolean): Promise<Export>;
    sendExport(_export: Export, sync?: boolean): Promise<{
        retryDelay: number;
        retryexportIds: string[];
        success: boolean;
        error: Error;
    }>;
    sendExports(_exports: Export[], sync?: boolean): Promise<{
        retryDelay: number;
        retryexportIds: string[];
        success: boolean;
        error: Error;
    }>;
    runExportProcessor(exportProcessor: ExportProcessor): Promise<{
        success: boolean;
        error: Error;
        retryDelay: number;
        retryexportIds: string[];
    } | {
        success: boolean;
        error: DestinationOps.CombinedError;
        retryDelay?: undefined;
        retryexportIds?: undefined;
    }>;
    validateUniqueAppAndOptionsForGroup(options?: SimpleDestinationOptions): Promise<void>;
    getConfigId(): string;
    getConfigObject(): Promise<DestinationConfigurationObject>;
    static ensureModel(instance: Destination): Promise<void>;
    static ensureAppReady(instance: Destination): Promise<void>;
    static ensureSupportedAppType(instance: Destination): Promise<void>;
    static ensureExportRecordsMethod(instance: Destination): Promise<void>;
    static validateSyncMode(instance: Destination): Promise<void>;
    static validateRecordCollectionMode(instance: Destination): Promise<void>;
    static ensureOnlyOneDestinationPerAppWithSameSettingsAndGroup(instance: Destination): Promise<void>;
    static updateState(instance: Destination): Promise<void>;
    static noUpdateIfLocked(instance: Destination): Promise<void>;
    static noDestroyIfLocked(instance: Destination): Promise<void>;
    static waitForPendingExports(instance: Destination): Promise<void>;
    static destroyDestinationMappings(instance: Destination): Promise<number>;
    static destroyDestinationOptions(instance: Destination): Promise<number>;
    static destroyDestinationGroupMemberships(instance: Destination): Promise<number>;
    static unassociateRelatedExports(instance: Destination): Promise<[affectedCount: number]>;
    static invalidateCache(): Promise<void>;
}
export {};