/// <reference types="node" />
import { GroupMember } from "./GroupMember";
import { Group } from "./Group";
import { RecordProperty } from "./RecordProperty";
import { Import } from "./Import";
import { Export } from "./Export";
import { RecordConfigurationObject } from "../classes/codeConfig";
import { Source } from "./Source";
import { GrouparooModel } from "./GrouparooModel";
import { CommonModel } from "../classes/commonModel";
declare const STATES: readonly ["draft", "pending", "ready", "deleted"];
export declare class GrouparooRecord extends CommonModel<GrouparooRecord> {
    idPrefix(): string;
    state: typeof STATES[number];
    invalid: boolean;
    modelId: string;
    recordProperties: RecordProperty[];
    groupMembers: GroupMember[];
    groups: Group[];
    model: GrouparooModel;
    imports: Import[];
    exports: Export[];
    apiData(): 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;
    }>;
    getProperties(): Promise<import("../modules/ops/record").RecordPropertyType>;
    simplifiedProperties(): Promise<{
        [key: string]: (string | number | boolean | Date)[];
    }>;
    addOrUpdateProperties(properties: {
        [key: string]: (string | number | boolean | Date)[];
    }, toLock?: boolean, ignoreMissingProperties?: boolean): Promise<void>;
    removeProperty(key: string): Promise<number>;
    removeProperties(properties: string[]): Promise<void>;
    buildNullProperties(state?: RecordProperty["state"]): Promise<number>;
    markPending(): Promise<void>;
    sync(force?: boolean, toExport?: boolean): Promise<Export[]>;
    snapshot(saveExports?: boolean): Promise<{
        properties: import("../modules/ops/record").RecordPropertyType;
        groups: {
            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;
        }[];
        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("./Export").ExportRecordProperties;
            newRecordProperties: import("./Export").ExportRecordProperties;
            oldGroups: string[];
            newGroups: string[];
            toDelete: boolean;
            hasChanges: boolean;
            errorMessage: string;
            errorLevel: "error" | "info";
        }[];
    }>;
    updateGroupMembership(): Promise<{
        [groupId: string]: boolean;
    }>;
    import(toSave?: boolean, toLock?: boolean): Promise<GrouparooRecord>;
    export(force?: boolean, additionalGroups?: Group[], saveExports?: boolean, sync?: boolean, toDelete?: boolean): Promise<Export[]>;
    validateRecordPropertiesAreReady(): Promise<void>;
    getConfigObject(): Promise<RecordConfigurationObject>;
    static findOrCreateByUniqueRecordProperties(hash: {
        [key: string]: (string | number | boolean | Date)[];
    }, source?: boolean | Source): Promise<{
        referenceId: string;
        record: GrouparooRecord;
        isNew: boolean;
        error: NodeJS.ErrnoException;
        hash: Record<string, (string | number | boolean | Date)[]>;
        uniquePropertiesHash: Record<string, (string | number | boolean | Date)[]>;
    }>;
    static ensureModel(instance: GrouparooRecord): Promise<void>;
    static updateState(instance: GrouparooRecord): Promise<void>;
    static buildNullPropertiesForNewRecord(instance: GrouparooRecord): Promise<void>;
    static destroyRecordProperties(instance: GrouparooRecord): Promise<void>;
    static destroyGroupMembers(instance: GrouparooRecord): Promise<void>;
    static destroyImports(instance: GrouparooRecord): Promise<void>;
}
export {};