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

The Grouparoo Core

import { Action, ParamsFrom } from "actionhero";
import { AuthenticatedAction } from "../classes/actions/authenticatedAction";
import { GrouparooRecord } from "../models/GrouparooRecord";
import { Group } from "../models/Group";
import { APIData } from "../modules/apiData";
import { ActionPermission } from "../models/Permission";
import { AsyncReturnType } from "type-fest";
import { TeamMember } from "../models/TeamMember";
export declare class RecordsList extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly groupId: {
            readonly required: false;
        };
        readonly searchKey: {
            readonly required: false;
        };
        readonly searchValue: {
            readonly required: false;
        };
        readonly state: {
            readonly required: false;
        };
        readonly modelId: {
            readonly required: false;
        };
        readonly caseSensitive: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureBoolean;
        };
        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 order: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureArray;
            readonly default: readonly [readonly ["createdAt", "asc"]];
        };
    };
    runWithinTransaction({ params }: {
        params: ParamsFrom<RecordsList>;
    }): Promise<{
        total: number;
        records: {
            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;
        }[];
    }>;
}
export declare class RecordAutocompleteRecordProperty extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly propertyId: {
            readonly required: true;
        };
        readonly match: {
            readonly required: true;
        };
        readonly limit: {
            readonly required: false;
            readonly default: 25;
            readonly formatter: typeof APIData.ensureNumber;
        };
        readonly offset: {
            readonly required: false;
            readonly default: 0;
            readonly formatter: typeof APIData.ensureNumber;
        };
        readonly order: {
            readonly required: false;
            readonly formatter: typeof APIData.ensureArray;
            readonly default: readonly [readonly ["rawValue", "asc"]];
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<RecordAutocompleteRecordProperty>;
    }): Promise<{
        recordProperties: (string | number | boolean | Date)[];
    }>;
}
export declare class RecordsImportAndUpdate extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {};
    runWithinTransaction({ session, }: {
        session: {
            teamMember: TeamMember;
        };
    }): Promise<{
        run: {
            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("..").HighWaterMark;
            sourceOffset: string | number;
            memberLimit: number;
            memberOffset: number;
            method: string;
            destinationId: string;
            createdAt: number;
            updatedAt: number;
            completedAt: number;
        };
    }>;
}
export declare class RecordCreate extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly modelId: {
            readonly required: true;
        };
        readonly properties: {
            readonly required: false;
            readonly default: {};
            readonly formatter: typeof APIData.ensureObject;
        };
    };
    runWithinTransaction({ params }: {
        params: ParamsFrom<RecordCreate>;
    }): 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;
        };
        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("..").DestinationSyncOperations;
            }[];
            collection: "none" | "group" | "model";
            app: {
                id: string;
                name: string;
                icon: string;
                type: string;
                state: "ready" | "draft" | "deleted";
                locked: string;
                options: import("../modules/optionHelper").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: import("../modules/mappingHelper").MappingHelper.Mappings;
            options: import("../modules/optionHelper").OptionHelper.SimpleOptions;
            connection: import("..").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 RecordImport extends Action {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    middleware: string[];
    inputs: {
        readonly id: {
            readonly required: true;
        };
    };
    run({ params }: {
        params: ParamsFrom<RecordImport>;
    }): Promise<{
        success: boolean;
        record: AsyncReturnType<GrouparooRecord["apiData"]>;
        groups: AsyncReturnType<Group["apiData"]>[];
    }>;
}
export declare class RecordsImport extends Action {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    middleware: string[];
    inputs: {
        readonly modelId: {
            readonly required: true;
        };
    };
    run({ params }: {
        params: ParamsFrom<RecordsImport>;
    }): Promise<{
        responses: {
            recordId: string;
            error: string;
            success: boolean;
        }[];
    }>;
}
export declare class RecordExport extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params }: {
        params: ParamsFrom<RecordExport>;
    }): Promise<{
        success: boolean;
        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;
        };
        exports: {
            id: string;
            destination: {
                id: string;
                state: "ready" | "draft" | "deleted";
                name: string;
                groupId: string;
                modelId: string;
            };
            destinationName: string;
            recordId: string;
            modelId: string;
            exportProcessorId: string;
            state: "failed" | "canceled" | "complete" | "pending" | "draft" | "processing";
            force: boolean;
            createdAt: number;
            sendAt: number;
            startedAt: number;
            completedAt: number;
            retryCount: number;
            oldRecordProperties: import("../models/Export").ExportRecordProperties;
            newRecordProperties: import("../models/Export").ExportRecordProperties;
            oldGroups: string[];
            newGroups: string[];
            toDelete: boolean;
            hasChanges: boolean;
            errorMessage: string;
            errorLevel: "error" | "info";
        }[];
    }>;
}
export declare class RecordView extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params }: {
        params: ParamsFrom<RecordView>;
    }): 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;
        };
        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("..").DestinationSyncOperations;
            }[];
            collection: "none" | "group" | "model";
            app: {
                id: string;
                name: string;
                icon: string;
                type: string;
                state: "ready" | "draft" | "deleted";
                locked: string;
                options: import("../modules/optionHelper").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: import("../modules/mappingHelper").MappingHelper.Mappings;
            options: import("../modules/optionHelper").OptionHelper.SimpleOptions;
            connection: import("..").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 RecordDestroy extends AuthenticatedAction {
    name: string;
    description: string;
    outputExample: {};
    permission: ActionPermission;
    inputs: {
        readonly id: {
            readonly required: true;
        };
    };
    runWithinTransaction({ params, }: {
        params: ParamsFrom<RecordDestroy>;
    }): Promise<{
        success: boolean;
    }>;
}