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

The Grouparoo Core

import { PropertyConfigurationObject } from "../classes/codeConfig";
import { FilterHelper } from "../modules/filterHelper";
import { OptionHelper } from "../modules/optionHelper";
import { Filter } from "./Filter";
import { Option } from "./Option";
import { GrouparooRecord } from "./GrouparooRecord";
import { RecordProperty } from "./RecordProperty";
import { Source } from "./Source";
import { CommonModel } from "../classes/commonModel";
declare const jsMap: {
    readonly boolean: "boolean" | "text";
    readonly date: "bigint";
    readonly email: "text";
    readonly float: "float";
    readonly integer: "bigint";
    readonly phoneNumber: "text";
    readonly string: "text";
    readonly url: "text";
};
export declare const propertyJSToSQLType: (jsType: keyof typeof jsMap) => "bigint" | "boolean" | "float" | "text";
export declare const PropertyTypes: readonly ["boolean", "date", "email", "float", "integer", "phoneNumber", "string", "url"];
export interface SimplePropertyOptions extends OptionHelper.SimpleOptions {
}
declare const STATES: readonly ["draft", "ready", "deleted"];
export interface PropertyFiltersWithKey extends FilterHelper.FiltersWithKey {
}
export declare class Property extends CommonModel<Property> {
    idPrefix(): string;
    key: string;
    type: typeof PropertyTypes[number];
    unique: boolean;
    sourceId: string;
    state: typeof STATES[number];
    locked: string;
    isPrimaryKey: boolean;
    isArray: boolean;
    source: Source;
    __options: Option[];
    filters: Filter[];
    RecordProperties: RecordProperty[];
    parameterizedQueryFromRecord(q: string, record: GrouparooRecord): Promise<string>;
    test(options?: SimplePropertyOptions): Promise<import("..").RecordPropertyPluginMethodResponse>;
    getOptions(sourceFromEnvironment?: boolean): Promise<OptionHelper.SimpleOptions>;
    setOptions(options: SimplePropertyOptions, test?: boolean, externallyValidate?: boolean): Promise<void>;
    afterSetOptions(hasChanges: boolean): Promise<void>;
    validateOptions(options?: SimplePropertyOptions, externallyValidate?: boolean): Promise<void>;
    getPlugin(): Promise<{
        plugin: import("..").GrouparooPlugin;
        pluginConnection: import("..").PluginConnection;
        pluginApp: import("..").PluginApp;
    }>;
    getFilters(): Promise<FilterHelper.FiltersWithKey[]>;
    setFilters(filters: PropertyFiltersWithKey[], externallyValidate?: boolean): Promise<void>;
    afterSetFilters(hasChanges: boolean): Promise<void>;
    pluginOptions(propertyOptions?: SimplePropertyOptions): Promise<{
        key: string;
        displayName?: string;
        description: string;
        required: boolean;
        type: import("..").PluginOptionType;
        options: {
            key: string;
            description?: string;
            default?: boolean;
            examples?: any[];
        }[];
    }[]>;
    validateFilters(filters: PropertyFiltersWithKey[]): Promise<void>;
    apiData(): Promise<{
        id: string;
        sourceId: string;
        key: string;
        type: "string" | "boolean" | "url" | "float" | "integer" | "date" | "email" | "phoneNumber";
        state: "ready" | "draft" | "deleted";
        unique: boolean;
        isPrimaryKey: boolean;
        locked: string;
        options: OptionHelper.SimpleOptions;
        filters: FilterHelper.FiltersWithKey[];
        isArray: boolean;
        createdAt: number;
        updatedAt: number;
        recordProperties: {
            recordId: string;
            property: Property;
            state: "pending" | "ready" | "draft";
            valueChangedAt: number;
            stateChangedAt: number;
            confirmedAt: number;
            startedAt: number;
            position: number;
            unique: boolean;
            key: string;
            value: string | number | boolean | Date;
            invalidValue: string;
            invalidReason: string;
        }[];
    }>;
    getConfigId(): string;
    getConfigObject(): Promise<PropertyConfigurationObject>;
    static ensureUniquePrimaryKey(instance: Property): Promise<void>;
    static ensureOptions(instance: Property): Promise<void>;
    static updateState(instance: Property): Promise<void>;
    static ensureNonArrayAndUnique(instance: Property): Promise<void>;
    static ensureUniqueProperties(instance: Property): Promise<void>;
    static ensureSourceReady(instance: Property): Promise<void>;
    static validateQuery(instance: Property): Promise<void>;
    static validateReservedKeys(instance: Property): Promise<void>;
    static noUniqueOrArrayThroughNonUniqueMapping(instance: Property): Promise<void>;
    static noUpdateIfLocked(instance: Property): Promise<void>;
    static runPropertyWithNoOptionsOrFiltersWhenReady(instance: Property): Promise<void>;
    static updateRecordPropertyUniqueness(instance: Property): Promise<void>;
    static ensureNotInUse(instance: Property, excludeMappingOwnerIds?: string[]): Promise<void>;
    static updateRecordsOnTypeChange(instance: Property): Promise<void>;
    static updateSampleRecords(instance: Property): Promise<void>;
    static noDestroyIfLocked(instance: Property): Promise<void>;
    static destroyOptions(instance: Property): Promise<void>;
    static stopRuns(instance: Property): Promise<void>;
    static destroyFilters(instance: Property): Promise<void>;
    static destroyRecordProperties(instance: Property): Promise<void>;
    static invalidateCache(): Promise<void>;
}
export {};