import Endpoint, { FileFindOptions, FindOptions } from '../endpoint';
import { Addon, InstalledAddon, AddonVersion, AddonAPIAsyncResult, AddonData, AddonDataScheme, Relation, Job, AddonFile, ElasticSearchDocument, DIMXObject, SearchBody, SearchData, TemporaryFileRequest, TemporaryFile, CrawlerInput, MultiCrawlerInput, DistinctValuesBody, DistinctValuesResponse, MultiGetInput, MultiGetOutput, FilterObject, NebulusRebuildInput, InsertOutput } from '../entities';
import { DataImportInput, FileExportInput, FileImportInput, MappingInput, RecursiveExportInput, RecursiveImportInput } from '../entities/dimx_inputs';
import { PapiClient } from '../papi-client';
import { ConfigurationsEndpoints } from './configurations';
import { UpdateByQueryResponse, DataIndexBatchRequestBody } from '../entities/data-index';
declare class InstalledAddonEnpoint {
    private service;
    private addonUUID;
    constructor(service: PapiClient, addonUUID: string);
    install(version?: string, forceUpgrade?: boolean): Promise<AddonAPIAsyncResult>;
    uninstall(): Promise<AddonAPIAsyncResult>;
    upgrade(version?: string, forceUpgrade?: boolean): Promise<AddonAPIAsyncResult>;
    downgrade(version: string): Promise<AddonAPIAsyncResult>;
    get(): Promise<InstalledAddon>;
}
declare class InstalledAddonsEnpoint extends Endpoint<InstalledAddon> {
    constructor(service: PapiClient);
    addonUUID(uuid: string): InstalledAddonEnpoint;
}
declare class AddonApiEndpoint {
    private service;
    private options;
    constructor(service: PapiClient);
    uuid(uuid: string): this;
    file(fileName: string): this;
    func(functionName: string): this;
    sync(): this;
    async(): this;
    get(params?: any): Promise<any>;
    post(params?: any, body?: any): Promise<any>;
    private GetAddonApiUrl;
}
declare class AddonVersionEndpoint extends Endpoint<AddonVersion> {
    constructor(service: PapiClient);
}
declare class BatchEndpoint {
    private service;
    private baseURL;
    private body;
    private headers;
    constructor(service: PapiClient, baseURL: string, body: {
        Objects: AddonData[];
        OverwriteObject?: boolean;
        WriteMode?: 'Merge' | 'Overwrite' | 'Insert';
        MaxPageSize?: number;
    }, headers?: any);
    uuid(addonUUID: string): {
        resource: (resourceName: string) => Promise<DIMXObject[]>;
    };
}
declare class DistinctValuesEndpoint {
    private service;
    private baseURL;
    private body;
    private headers;
    constructor(service: PapiClient, baseURL: string, body: DistinctValuesBody, headers?: any);
    uuid(addonUUID: string): {
        resource: (resourceName: string) => Promise<DistinctValuesResponse>;
    };
}
declare class TableEndpoint extends Endpoint<AddonData> {
    private addonUUID;
    private tableName;
    constructor(service: PapiClient, addonUUID: string, tableName: string);
    upsert(object: AddonData, waitForIndex?: boolean): Promise<AddonData>;
    key(keyName: string): {
        get: () => Promise<AddonData>;
        hardDelete: (force?: boolean) => Promise<AddonData>;
    };
}
export declare class AddonEndpoint extends Endpoint<Addon> {
    constructor(service: PapiClient);
    installedAddons: InstalledAddonsEnpoint;
    versions: AddonVersionEndpoint;
    api: AddonApiEndpoint;
    configurations: ConfigurationsEndpoints;
    data: {
        schemes: {
            get: (params: FindOptions) => Promise<AddonDataScheme[]>;
            name: (name: string) => {
                get: () => Promise<AddonDataScheme>;
            };
            post: (body: AddonDataScheme) => Promise<AddonDataScheme>;
        };
        uuid: (addonUUID: string) => {
            table: (tableName: string) => TableEndpoint;
        };
        batch: (body: {
            Objects: AddonData[];
            OverwriteObject?: boolean;
            WriteMode?: 'Merge' | 'Overwrite' | 'Insert';
            MaxPageSize?: number;
        }, headers?: any) => BatchEndpoint;
        distinct_values: (body: DistinctValuesBody, headers?: any) => DistinctValuesEndpoint;
        relations: Endpoint<Relation>;
        import: {
            uuid: (addonUUID: string) => {
                table: (tableName: string) => {
                    upsert: (body: DataImportInput) => Promise<DIMXObject[]>;
                };
            };
            file: {
                uuid: (addonUUID: string) => {
                    table: (tableName: string) => {
                        upsert: (body: FileImportInput) => Promise<AddonAPIAsyncResult>;
                    };
                };
                recursive: {
                    uuid: (addonUUID: string) => {
                        table: (tableName: string) => {
                            upsert: (body: RecursiveImportInput) => Promise<AddonAPIAsyncResult>;
                        };
                    };
                };
            };
        };
        export: {
            file: {
                uuid: (addonUUID: string) => {
                    table: (tableName: string) => {
                        get: (body: FileExportInput) => Promise<AddonAPIAsyncResult>;
                    };
                };
                recursive: {
                    uuid: (addonUUID: string) => {
                        table: (tableName: string) => {
                            get: (body: RecursiveExportInput) => Promise<AddonAPIAsyncResult>;
                        };
                    };
                };
            };
        };
        mapping: {
            uuid: (addonUUID: string) => {
                table: (tableName: string) => {
                    upsert: (body: MappingInput) => Promise<AddonAPIAsyncResult>;
                };
            };
        };
        search: {
            uuid: (addonUUID: string) => {
                table: (tableName: string) => {
                    post: (searchBody: SearchBody) => Promise<SearchData<AddonData>>;
                };
            };
        };
        multi_get: (input: MultiGetInput) => Promise<MultiGetOutput>;
        insert: {
            uuid: (addonUUID: string) => {
                table: (tableName: string) => {
                    post: (object: unknown) => Promise<InsertOutput>;
                };
            };
        };
    };
    index: {
        schemes: {
            uuid: (addonUUID: string) => {
                create: (body: ElasticSearchDocument) => Promise<any>;
                purge: (body: ElasticSearchDocument) => Promise<any>;
            };
        };
        uuid: (addonUUID: string) => {
            resource: (resourceName: string) => {
                create: (body: ElasticSearchDocument) => Promise<any>;
                key: (key: string) => {
                    get: () => Promise<ElasticSearchDocument>;
                };
                find: (params: FindOptions) => Promise<ElasticSearchDocument[]>;
            };
        };
        batch: (body: DataIndexBatchRequestBody, headers?: any) => BatchEndpoint;
        distinct_values: (body: DistinctValuesBody, headers?: any) => DistinctValuesEndpoint;
        search: (dslQuery: any) => {
            uuid: (addonUUID: string) => {
                resource: (resourceName: string) => Promise<any>;
            };
        };
        delete: (dslQuery: any) => {
            uuid: (addonUUID: string) => {
                resource: (resourceName: string) => Promise<any>;
            };
        };
        update: (dslQuery: any) => {
            uuid: (addonUUID: string) => {
                resource: (resourceName: string) => Promise<UpdateByQueryResponse>;
            };
        };
    };
    shared_index: {
        schemes: {
            uuid: (addonUUID: string) => {
                create: (body: ElasticSearchDocument) => Promise<any>;
                purge: (body: ElasticSearchDocument) => Promise<any>;
            };
        };
        index: {
            index_name: (indexName: string) => {
                uuid: (addonUUID: string) => {
                    resource: (resourceName: string) => {
                        create: (body: ElasticSearchDocument) => Promise<any>;
                        key: (key: string) => {
                            get: () => Promise<ElasticSearchDocument>;
                        };
                        find: (params: FindOptions) => Promise<ElasticSearchDocument[]>;
                    };
                };
                batch: (body: DataIndexBatchRequestBody, headers?: any) => BatchEndpoint;
                distinct_values: (body: DistinctValuesBody, headers?: any) => DistinctValuesEndpoint;
                search: (dslQuery: any) => {
                    uuid: (addonUUID: string) => {
                        resource: (resourceName: string) => Promise<any>;
                    };
                };
                delete: (dslQuery: any) => {
                    uuid: (addonUUID: string) => {
                        resource: (resourceName: string) => Promise<any>;
                    };
                };
                update: (dslQuery: any) => {
                    uuid: (addonUUID: string) => {
                        resource: (resourceName: string) => Promise<UpdateByQueryResponse>;
                    };
                };
            };
        };
    };
    pfs: {
        uuid: (addonUUID: string) => {
            schema: (schemaName: string) => {
                key: (keyName: string) => {
                    get: () => Promise<AddonFile>;
                };
                find: (params: FileFindOptions) => Promise<AddonFile[]>;
                post: (body: AddonFile) => Promise<AddonFile>;
            };
        };
        temporaryFile: (temporaryFileRequest?: TemporaryFileRequest | undefined) => Promise<TemporaryFile>;
    };
    jobs: {
        uuid: (uuid: string) => {
            get: () => Promise<Job>;
        };
        find: (params: FindOptions) => Promise<Job[]>;
    };
    crawler: {
        crawl: (input: CrawlerInput, numberOfRetries?: number, callbackEncodedUrl?: string | undefined) => Promise<AddonAPIAsyncResult>;
        multi_crawl: (input: MultiCrawlerInput, numberOfRetries?: number, callbackEncodedUrl?: string | undefined) => Promise<AddonAPIAsyncResult>;
    };
    febula: {
        profile_filters: {
            find: (params: FindOptions) => Promise<FilterObject[]>;
            upsert: (body: FilterObject) => Promise<FilterObject>;
        };
        filters: {
            find: (params: FindOptions) => Promise<FilterObject[]>;
            upsert: (body: FilterObject) => Promise<FilterObject>;
        };
    };
    nebulus: {
        rebuild: (param: NebulusRebuildInput, callbackEncodedUrl?: string | undefined) => Promise<AddonAPIAsyncResult>;
    };
}
export {};