import { Block, Condition, Content, ContentRelationInfo, FPApplication, FPFile, FPFunction, FPPackage, FPPackageResponse, ManagerOption, Material, PackageFreshOption, PackageNamedVersion, Page, Relations, ResourceUpdateInfo, Tag, Template, TicketCheckData, Variable } from '@foxpage/foxpage-types';
import { FoxpageRequest } from './request';
declare let foxpageDataService: FoxpageDataService;
type RequestApiOption = ManagerOption['dataService'];
/**
 * foxpage data service
 *
 * @export
 * @class FoxpageDataService
 */
export declare class FoxpageDataService {
    /**
     * foxpage webApi request
     *
     * @protected
     * @type {FoxpageRequest}
     */
    protected request: FoxpageRequest;
    /**
     * request option
     */
    private option;
    constructor(opt: RequestApiOption);
    /**
     * update request instance
     * @param opt
     * @param cache if cache the option
     */
    update(data?: Partial<RequestApiOption>, cache?: boolean): void;
    /**
     * fetch app details via appIds
     *
     * @param {string[]} appIds
     * @return {*}
     */
    fetchApps(appIds: string[]): Promise<FPApplication[]>;
    /**
     * fetch changes
     *
     * @param {string} appId
     * @param {number} timestamp
     * @return {*}  {Promise<{
        contents: ResourceUpdateInfo;
        timestamp: number;
      }>}
     */
    fetchContentChanges(appId: string, timestamp: number): Promise<{
        contents: ResourceUpdateInfo;
        timestamp: number;
    }>;
    private fetchPackageLives;
    private fetchPackageInfos;
    /**
     * fetch application live package
     *
     * @param {string} appId
     * @param {{ packageIds: string[] }} packageIds
     */
    fetchPackages(appId: string, opt: {
        packageIds?: string[];
    } & Pick<PackageFreshOption, 'strategy' | 'semver'>): Promise<FPPackage[]>;
    /**
     * fetch packages by name and version
     *
     * @param {string} appId application id
     * @param {{ nameVersions: PackageNamedVersion[] }} { nameVersions }
     * @return {Promise<FPPackageResponse[]>}
     */
    fetchPackagesByNamedVersions(appId: string, opt: {
        nameVersions: PackageNamedVersion[];
        isCanary?: boolean;
    } & Pick<PackageFreshOption, 'semver'>): Promise<FPPackageResponse[]>;
    /**
     * fetch application live plugin
     *
     * @param {string} appId
     * @param {{ packageIds: string[] }} packageIds
     * @return {Promise<FPPackage[]>}
     */
    fetchPlugins(appId: string, opt: {
        packageIds?: string[];
    } & Pick<PackageFreshOption, 'strategy' | 'semver'>): Promise<FPPackage[]>;
    /**
     * fetch plugins by name and version
     *
     * @param {string} appId application id
     * @param {{ nameVersions: PackageNamedVersion[] }} { nameVersions }
     * @return {Promise<FPPackageResponse[]>}
     */
    fetchPluginsByNamedVersions(appId: string, opt: {
        nameVersions: PackageNamedVersion[];
        isCanary?: boolean;
    } & Pick<PackageFreshOption, 'semver'>): Promise<FPPackageResponse[]>;
    /**
     * fetch application live library
     *
     * @param {string} appId
     * @param {{ packageIds: string[] }} libraryIds
     * @return {Promise<FPPackage[]>}
     */
    fetchLibraries(appId: string, opt: {
        packageIds?: string[];
    } & Pick<PackageFreshOption, 'strategy' | 'semver'>): Promise<FPPackage[]>;
    /**
     * fetch libraries by name and version
     *
     * @param {string} appId application id
     * @param {{ nameVersions: PackageNamedVersion[] }} { nameVersions }
     * @return {Promise<FPPackageResponse[]>}
     */
    fetchLibrariesByNamedVersions(appId: string, opt: {
        nameVersions: PackageNamedVersion[];
        isCanary?: boolean;
    } & Pick<PackageFreshOption, 'semver'>): Promise<FPPackageResponse[]>;
    /**
     * fetch application pages
     *
     * @param {string} appId
     * @param {{ pageIds: string[] }} { page content ids }
     * @return {Promise<Page[]>}
     */
    fetchPages(appId: string, { pageIds }: {
        pageIds?: string[];
    }): Promise<Page[]>;
    /**
     * fetch application templates
     *
     * @param {string} appId
     * @param {{ templateIds: string[] }} { template content ids }
     * @return {Promise<Template[]>}
     */
    fetchTemplates(appId: string, { templateIds }: {
        templateIds?: string[];
    }): Promise<Template[]>;
    /**
     * fetch application blocks
     *
     * @param {string} appId
     * @param {{ blockIds: string[] }} { template content ids }
     * @return {Promise<Block[]>}
     */
    fetchBlocks(appId: string, { blockIds }: {
        blockIds?: string[];
    }): Promise<Block[]>;
    /**
     * fetch application content via tags
     *
     * @param {string} appId
     * @param {Tag[]} tags tags
     * @return {*}  {(Promise<{
                        content: Content;
                        contentInfo: Relations;
                    }>)}
     */
    fetchContentInfoByTags(appId: string, fileId: string, pathname: string, tags: Tag[]): Promise<{
        content: Content;
        contentInfo?: Relations;
    }>;
    /**
     * fetch content by tag
     *
     * @param {string} appId
     * @param {string} pathname
     * @param {Tag[]} tags
     * @return {*}  {Promise<Content>}
     */
    fetchContentByTags(appId: string, fileId: string, pathname: string, tags: Tag[]): Promise<Content>;
    /**
     * fetch application content
     * contain contentId and tags
     * @param {string} appId
     * @param {string[]} contentIds
     * @return {*}  {Promise<Content[]>}
     */
    fetchContents(appId: string, { contentIds }: {
        contentIds: string[];
    }): Promise<Content[]>;
    /**
     * fetch application functions
     *
     * @param {string} appId
     * @param {{ functionIds: string[] }} { function content ids }
     * @return {*}  {Promise<FPFunction[]>}
     */
    fetchFunctions(appId: string, { functionIds }: {
        functionIds: string[];
    }): Promise<FPFunction[]>;
    /**
     * fetch application conditions
     *
     * @param {string} appId
     * @param {{ conditionIds: string[] }} { condition content ids }
     * @return {*}  {Promise<Condition[]>}
     */
    fetchConditions(appId: string, { conditionIds }: {
        conditionIds: string[];
    }): Promise<Condition[]>;
    /**
     * fetch application variables
     *
     * @param {string} appId
     * @param {{ variableIds: string[] }} { variable content ids }
     * @return {*}  {(Promise<Variable[]>)}
     */
    fetchVariables(appId: string, { variableIds }: {
        variableIds: string[];
    }): Promise<Variable[]>;
    /**
     * fetch application materials
     *
     * @param {string} appId
     * @param {{ materialIds: string[] }} { material content ids }
     * @return {*}  {(Promise<Variable[]>)}
     */
    fetchMaterials(appId: string, { items, materialIds }: {
        items?: Record<string, string>[];
        materialIds?: string[];
    }): Promise<Material[]>;
    /**
     * fetch application mocks
     *
     * @param {string} appId
     * @param {{ mockIds: string[] }} { mock content ids }
     * @return {*}  {(Promise<ContentRelationInfo[]>)}
     */
    fetchMocks(appId: string, { mockIds }: {
        mockIds: string[];
    }): Promise<ContentRelationInfo[]>;
    /**
     * fetch application draft mocks
     * @param appId
     * @param params
     * @returns
     */
    fetchDraftMocks(appId: string, { mockIds }: {
        mockIds: string[];
    }): Promise<ContentRelationInfo[]>;
    /**
     * fetch content & relations info
     *
     * @param {string} appId
     * @param {{ contentIds: string[] }} { contentIds }
     * @return {*}
     */
    fetchPageInfos(appId: string, { contentIds }: {
        contentIds: string[];
    }): Promise<ContentRelationInfo[]>;
    /**
     * fetch content & relations info
     *
     * @param {string} appId
     * @param {{ contentIds: string[] }} { contentIds }
     * @return {*}
     */
    fetchBlockRelationInfos(appId: string, { contentIds }: {
        contentIds: string[];
    }): Promise<ContentRelationInfo[]>;
    /**
     * fetch content & relation info in draft status
     *
     * @param {string} appId
     * @param {{ contentIds: string[] }} { contentIds }
     * @return {*}
     */
    fetchDraftPageInfos(appId: string, { contentIds, locale }: {
        contentIds: string[];
        locale?: string;
    }): Promise<ContentRelationInfo[]>;
    /**
     * fetch preview version content & relation infos
     * @param appId
     * @param param
     * @returns
     */
    fetchPreviewPageInfos(appId: string, { contentId, version, locale }: {
        contentId: string;
        version: number;
        locale?: string;
    }): Promise<ContentRelationInfo>;
    /**
     * fetch block content & relation info in draft status
     *
     * @param {string} appId
     * @param {{ contentIds: string[] }} { contentIds }
     * @return {*}
     */
    fetchDraftBlockRelationInfos(appId: string, { contentIds }: {
        contentIds: string[];
    }): Promise<ContentRelationInfo[]>;
    /**
     * fetch preview version block content & relation infos
     * @param appId
     * @param param
     * @returns
     */
    fetchPreviewBlockRelationInfos(appId: string, { contentId, version }: {
        contentId: string;
        version: number;
    }): Promise<ContentRelationInfo>;
    /**
     * fetch files
     *
     * @param {string} appId
     * @param {{ fileIds: string[] }} { fileIds }
     * @return {*}
     */
    fetchFiles(appId: string, { fileIds }: {
        fileIds: string[];
    }): Promise<FPFile[]>;
    /**
     * ticket check
     * @param appId
     * @param ticket
     * @returns boolean
     */
    ticketCheck(ticket: string, data: TicketCheckData): Promise<{
        status: boolean;
    }>;
}
/**
 * create data service
 * @param opt data service options
 */
export declare const createFoxpageDataService: (opt: RequestApiOption) => FoxpageDataService;
/**
 * get foxpage dataService instance
 * @returns {FoxpageDataService}
 */
export declare const getFoxpageDataService: () => FoxpageDataService;
export { foxpageDataService };