declare module "api.types" {
    export interface Config {
        endpoint: string;
        authCode?: string;
        type?: "json" | "xml" | string;
    }
    export interface GenericObject<T = any> {
        [key: string]: T;
    }
    export interface CallProps {
        body?: GenericObject;
        method?: "POST" | "GET";
        headers?: GenericObject<string>;
    }
    export interface CrudListCallProps {
        order?: GenericObject;
        filter?: GenericObject;
        select?: string[];
    }
    export interface CrudUpdateCallProps {
        id: number;
        fields: GenericObject;
        params?: GenericObject;
    }
    export interface APIType {
        call(path: string, params?: CallProps): Promise<any>;
    }
    export interface MethodsDefBuilder {
        [key: "add" | "delete" | "fields" | "get" | "list" | "update" | "noParams" | "withFieldsParam" | string]: (api: APIType, path: string) => (...params: any) => Promise<GenericObject>;
    }
    export interface MethodsBuilder {
        [key: string]: {
            key: string;
            callBuilder: (api: APIType, path: string) => (...params: any) => Promise<GenericObject>;
        };
    }
    export interface CrudDefaultMethodsType {
        add(fields: GenericObject): Promise<GenericObject>;
        fields(): Promise<GenericObject>;
        delete(id: string): Promise<GenericObject>;
        get(id: string): Promise<GenericObject>;
        list(options: CrudListCallProps): Promise<GenericObject>;
        update(options: CrudUpdateCallProps): Promise<GenericObject>;
    }
}
declare module "remoteCall" {
    import { CallProps } from "api.types";
    export const remoteCall: (endpointWithPath: string, params?: CallProps) => Promise<any>;
}
declare module "api" {
    import { APIType, CallProps, Config } from "api.types";
    export class API implements APIType {
        private readonly _endpoint;
        private readonly _type;
        private readonly _authCode?;
        constructor(config: Config);
        call(path: string, params?: CallProps): Promise<any>;
    }
}
declare module "api-helpers" {
    import { MethodsBuilder, MethodsDefBuilder } from "api.types";
    export const CRUD_METHODS_DEF: MethodsDefBuilder;
    export const CRUD_METHODS: MethodsBuilder;
    export const buildApiMethods: any;
}
declare module "crm/product-shared-methods/product-shared-method" {
    import { GenericObject, MethodsBuilder } from "api.types";
    export interface ProductSharedMethodApiType {
        productRowsGet(id: string): Promise<object>;
        productRowsSet(id: string, rows: GenericObject[]): Promise<object>;
    }
    export const PRODUCT_SHARED_METHODS: MethodsBuilder;
}
declare module "crm/user-shared-methods/user-shared-method.types" {
    import { GenericObject } from "api.types";
    export interface UserfieldSharedApiType {
        userfieldAdd(fields: GenericObject): Promise<object>;
        userfieldDelete(id: string): Promise<object>;
        userfieldGet(id: string): Promise<object>;
        userfieldList(order: GenericObject, filter: GenericObject): Promise<object>;
        userfieldUpdate(id: string, fields: GenericObject): Promise<object>;
    }
}
declare module "crm/leads/lead.types" {
    import { CrudDefaultMethodsType } from "api.types";
    import { ProductSharedMethodApiType } from "crm/product-shared-methods/product-shared-method";
    import { UserfieldSharedApiType } from "crm/user-shared-methods/user-shared-method.types";
    export interface LeadApiType extends CrudDefaultMethodsType, ProductSharedMethodApiType, UserfieldSharedApiType {
    }
}
declare module "crm/user-shared-methods/user-shared-method" {
    import { MethodsBuilder } from "api.types";
    export const USER_SHARED_METHODS: MethodsBuilder;
}
declare module "crm/leads/methods" {
    import { MethodsBuilder } from "api.types";
    export const LEAD_METHODS: MethodsBuilder;
}
declare module "crm/leads/leads" {
    import { Config } from "api.types";
    import { LeadApiType } from "crm/leads/lead.types";
    export const LeadAPI: (config: Config) => LeadApiType;
}
declare module "crm/leads/index" {
    export { LeadAPI } from "crm/leads/leads";
}
declare module "crm/deals/deal.types" {
    import { CrudDefaultMethodsType } from "api.types";
    import { ProductSharedMethodApiType } from "crm/product-shared-methods/product-shared-method";
    import { UserfieldSharedApiType } from "crm/user-shared-methods/user-shared-method.types";
    export interface DealApiType extends CrudDefaultMethodsType, ProductSharedMethodApiType, UserfieldSharedApiType {
    }
}
declare module "crm/deals/methods" {
    import { MethodsBuilder } from "api.types";
    export const DEAL_METHODS: MethodsBuilder;
}
declare module "crm/deals/deals" {
    import { Config } from "api.types";
    import { DealApiType } from "crm/deals/deal.types";
    export const DealAPI: (config: Config) => DealApiType;
}
declare module "crm/deals/index" {
    export { DealAPI } from "crm/deals/deals";
}
declare module "crm/products/product.types" {
    import { CrudDefaultMethodsType, GenericObject } from "api.types";
    interface ProductPropertyApiType {
        propertyAdd: (fields: GenericObject) => Promise<object>;
        propertyDelete(id: string): Promise<object>;
        propertyEnumerationFields(): Promise<object>;
        propertyFields(): Promise<object>;
        propertyGet(id: string): Promise<object>;
        propertyList(order: GenericObject, filter: GenericObject): Promise<object>;
        propertySettingsFields(propertyType: string, userType: string): Promise<object>;
        propertyTypes(): Promise<object>;
        propertyUpdate(id: string, fields: GenericObject): Promise<object>;
    }
    export interface ProductApiType extends CrudDefaultMethodsType, ProductPropertyApiType {
    }
}
declare module "crm/products/methods" {
    import { MethodsBuilder } from "api.types";
    export const PRODUCT_METHODS: MethodsBuilder;
}
declare module "crm/products/products" {
    import { Config } from "api.types";
    import { ProductApiType } from "crm/products/product.types";
    export const ProductAPI: (config: Config) => ProductApiType;
}
declare module "crm/products/index" {
    export { ProductAPI } from "crm/products/products";
}
declare module "crm/categories/category.types" {
    import { CrudUpdateCallProps, GenericObject } from "api.types";
    export interface CaregoryApiType {
        add(entityTypeId: number, fields: GenericObject): Promise<GenericObject>;
        fields(): Promise<GenericObject>;
        delete(entityTypeId: number, id: string): Promise<GenericObject>;
        get(entityTypeId: number, id: string): Promise<GenericObject>;
        list(entityTypeId: number): Promise<GenericObject>;
        update(entityTypeId: number, options: CrudUpdateCallProps): Promise<GenericObject>;
    }
}
declare module "crm/categories/methods" {
    import { MethodsBuilder, MethodsDefBuilder } from "api.types";
    export const CATEGORY_METHODS_DEF: MethodsDefBuilder;
    export const CATEGORY_METHODS: MethodsBuilder;
}
declare module "crm/categories/categories" {
    import { Config } from "api.types";
    import { CaregoryApiType } from "crm/categories/category.types";
    export const CategoryAPI: (config: Config) => CaregoryApiType;
}
declare module "crm/categories/index" {
    export { CategoryAPI } from "crm/categories/categories";
}
declare module "crm/contacts/contact.types" {
    import { CrudDefaultMethodsType, GenericObject } from "api.types";
    interface ContactCompanyApiType {
        companyAdd(id: string, fields: GenericObject): Promise<object>;
        companyDelete(id: string, fields: GenericObject): Promise<object>;
    }
    export interface ContactApiType extends CrudDefaultMethodsType, ContactCompanyApiType {
    }
}
declare module "crm/contacts/methods" {
    import { MethodsBuilder } from "api.types";
    export const CONTACT_METHODS: MethodsBuilder;
}
declare module "crm/contacts/contacts" {
    import { Config } from "api.types";
    import { ContactApiType } from "crm/contacts/contact.types";
    export const ContactAPI: (config: Config) => ContactApiType;
}
declare module "crm/contacts/index" {
    export { ContactAPI } from "crm/contacts/contacts";
}
declare module "crm/contact-shared-methods/contact-shared-method" {
    import { GenericObject, MethodsBuilder } from "api.types";
    export interface ContactSharedMethodApiType {
        contactAdd(id: string, fields: GenericObject): Promise<object>;
        contactDelete(id: string, fields: GenericObject): Promise<object>;
        contactFields(): Promise<object>;
        getItemsContact(id: string): Promise<object>;
        deleteItemsContact(id: string): Promise<object>;
        setItemsContact(id: string, items: GenericObject): Promise<object>;
    }
    export const CONTACT_SHARED_METHODS: MethodsBuilder;
}
declare module "crm/companies/company.types" {
    import { CrudDefaultMethodsType } from "api.types";
    import { UserfieldSharedApiType } from "crm/user-shared-methods/user-shared-method.types";
    import { ContactSharedMethodApiType } from "crm/contact-shared-methods/contact-shared-method";
    export interface CompanyApiType extends CrudDefaultMethodsType, UserfieldSharedApiType, ContactSharedMethodApiType {
    }
}
declare module "crm/companies/methods" {
    import { MethodsBuilder } from "api.types";
    export const COMPANY_METHODS: MethodsBuilder;
}
declare module "crm/companies/companies" {
    import { Config } from "api.types";
    import { CompanyApiType } from "crm/companies/company.types";
    export const CompanyAPI: (config: Config) => CompanyApiType;
}
declare module "crm/companies/index" {
    export { CompanyAPI } from "crm/companies/companies";
}
declare module "crm/comment-shared-methods/comment-shared-method" {
    import { GenericObject, MethodsBuilder } from "api.types";
    export interface CommentSharedMethodApiType {
        getComment(id: string): Promise<object>;
        updateComment(id: string, fields: GenericObject): Promise<object>;
        listComment(): Promise<object>;
        addComment(fields: GenericObject): Promise<object>;
        deleteComment(id: string): Promise<object>;
        commentFields(): Promise<object>;
    }
    export const COMMENT_SHARED_METHODS: MethodsBuilder;
}
declare module "crm/timeline/timeline.types" {
    import { CrudDefaultMethodsType, GenericObject } from "api.types";
    import { CommentSharedMethodApiType } from "crm/comment-shared-methods/comment-shared-method";
    interface customTimelineMethods {
        bindTimelineRecord: (fields: GenericObject) => Promise<object>;
        listTimelineRecord: (fields: GenericObject) => Promise<object>;
        timelineRecordFields: () => Promise<object>;
        unbindTimelineRecord: (fields: GenericObject) => Promise<object>;
    }
    export interface TimelineApiType extends CrudDefaultMethodsType, customTimelineMethods, CommentSharedMethodApiType {
    }
}
declare module "crm/timeline/methods" {
    import { MethodsBuilder } from "api.types";
    export const CUSTOM_TIMELINE_METHODS: MethodsBuilder;
    export const TIMELINE_METHODS: MethodsBuilder;
}
declare module "crm/timeline/timeline" {
    import { Config } from "api.types";
    import { TimelineApiType } from "crm/timeline/timeline.types";
    export const TimelineAPI: (config: Config) => TimelineApiType;
}
declare module "crm/timeline/index" {
    export { TimelineAPI } from "crm/timeline/timeline";
}
declare module "crm/index" {
    export { LeadAPI } from "crm/leads/index";
    export { DealAPI } from "crm/deals/index";
    export { ProductAPI } from "crm/products/index";
    export { CategoryAPI } from "crm/categories/index";
    export { ContactAPI } from "crm/contacts/index";
    export { CompanyAPI } from "crm/companies/index";
    export { TimelineAPI } from "crm/timeline/index";
}
declare module "drive/folders/folder.types" {
    import { CrudListCallProps, GenericObject } from "api.types";
    interface CustomFolderAPIMethods {
        get(id: string): Promise<GenericObject>;
        getChildren(id: string, options: CrudListCallProps): Promise<GenericObject>;
        addSubfolder(id: string, data: GenericObject): Promise<GenericObject>;
        copyTo(id: string, targetFolderId: string): Promise<GenericObject>;
        moveTo(id: string, targetFolderId: string): Promise<GenericObject>;
        rename(id: string, newName: string): Promise<GenericObject>;
        deleteTree(id: string): Promise<GenericObject>;
        markDeleted(id: string): Promise<GenericObject>;
        restore(id: string): Promise<GenericObject>;
        getExternalLink(id: string): Promise<GenericObject>;
        uploadFile(id: string, fileContent: any, data: GenericObject): Promise<GenericObject>;
    }
    export interface FolderApiType extends CustomFolderAPIMethods {
    }
}
declare module "drive/folders/methods" {
    import { MethodsBuilder } from "api.types";
    export const CUSTOM_FOLDER_METHODS: MethodsBuilder;
    export const FOLDER_METHODS: MethodsBuilder;
}
declare module "drive/folders/folders" {
    import { Config } from "api.types";
    import { FolderApiType } from "drive/folders/folder.types";
    export const FolderAPI: (config: Config) => FolderApiType;
}
declare module "drive/folders/index" {
    export { FolderAPI } from "drive/folders/folders";
}
declare module "drive/files/file.types" {
    import { CrudListCallProps, GenericObject } from "api.types";
    interface CustomFileAPIMethods {
        getFields(): Promise<GenericObject>;
        get(id: string, data: GenericObject): Promise<GenericObject>;
        rename(id: string, newName: string): Promise<GenericObject>;
        copyTo(id: string, targetFolderId: string): Promise<GenericObject>;
        moveTo(id: string, targetFolderId: string): Promise<GenericObject>;
        delete(id: string): Promise<GenericObject>;
        markDeleted(id: string): Promise<GenericObject>;
        restore(id: string): Promise<GenericObject>;
        uploadVersion(id: string, fileContent: any): Promise<GenericObject>;
        restoreFromVersion(id: string, versionId: string): Promise<GenericObject>;
        getVersions(id: string, options: CrudListCallProps): Promise<GenericObject>;
        getExternalLink(id: string): Promise<GenericObject>;
    }
    export interface FileApiType extends CustomFileAPIMethods {
    }
}
declare module "drive/files/methods" {
    import { MethodsBuilder } from "api.types";
    export const CUSTOM_FILE_METHODS: MethodsBuilder;
    export const FILE_METHODS: MethodsBuilder;
}
declare module "drive/files/files" {
    import { Config } from "api.types";
    import { FileApiType } from "drive/files/file.types";
    export const FileAPI: (config: Config) => FileApiType;
}
declare module "drive/files/index" {
    export { FileAPI } from "drive/files/files";
}
declare module "drive/storage/storage.types" {
    import { CrudListCallProps, GenericObject } from "api.types";
    interface CustomStorageAPIMethods {
        getFields(): Promise<GenericObject>;
        addFolder(id: string, data: GenericObject): Promise<GenericObject>;
        get(id: string): Promise<GenericObject>;
        getChildren(id: string, options: CrudListCallProps): Promise<GenericObject>;
        getForApp(): Promise<GenericObject>;
        getList(options: CrudListCallProps): Promise<GenericObject>;
        getTypes(): Promise<GenericObject>;
        rename(id: string, newName: string): Promise<GenericObject>;
        uploadFile(id: string, fileContent: any, data: GenericObject, generateUniqueName?: boolean, rights?: GenericObject[]): Promise<GenericObject>;
    }
    export interface StorageApiType extends CustomStorageAPIMethods {
    }
}
declare module "drive/storage/methods" {
    import { MethodsBuilder } from "api.types";
    export const CUSTOM_STORAGE_METHODS: MethodsBuilder;
    export const STORAGE_METHODS: MethodsBuilder;
}
declare module "drive/storage/storages" {
    import { Config } from "api.types";
    import { StorageApiType } from "drive/storage/storage.types";
    export const StorageAPI: (config: Config) => StorageApiType;
}
declare module "drive/storage/index" {
    export { StorageAPI } from "drive/storage/storages";
}
declare module "drive/index" {
    export { FolderAPI } from "drive/folders/index";
    export { FileAPI } from "drive/files/index";
    export { StorageAPI } from "drive/storage/index";
}
declare module "users/users/user.types" {
    import { CrudUpdateCallProps, GenericObject } from "api.types";
    interface CustomUserAPIMethods {
        add(fields: GenericObject): Promise<GenericObject>;
        update(options: CrudUpdateCallProps): Promise<GenericObject>;
        get(id?: string): Promise<GenericObject>;
        getFiltered(filter: GenericObject): Promise<GenericObject>;
        fields(): Promise<GenericObject>;
        search(fields: GenericObject): Promise<GenericObject>;
        current(): Promise<GenericObject>;
    }
    export interface UserApiType extends CustomUserAPIMethods {
    }
}
declare module "users/users/methods" {
    import { MethodsBuilder } from "api.types";
    export const USER_METHODS: MethodsBuilder;
}
declare module "users/users/users" {
    import { Config } from "api.types";
    import { UserApiType } from "users/users/user.types";
    export const UserAPI: (config: Config) => UserApiType;
}
declare module "users/users/index" {
    export { UserAPI } from "users/users/users";
}
declare module "users/index" {
    export { UserAPI } from "users/users/index";
}
declare module "socialNetworkGroups/socialNetworkGroups.types" {
    import { GenericObject } from "api.types";
    interface CustomSocialNetworkGroupsAPIMethods {
        groups(filter?: any, select?: any): Promise<GenericObject>;
        get(groupId: string, select?: string[]): Promise<GenericObject>;
    }
    export interface SocialNetworkGroups extends CustomSocialNetworkGroupsAPIMethods {
    }
}
declare module "socialNetworkGroups/methods" {
    import { MethodsBuilder } from "api.types";
    export const SOCIAL_NETWORL_GROUPS: MethodsBuilder;
}
declare module "socialNetworkGroups/socialNetworkGroups" {
    import { SocialNetworkGroups } from "socialNetworkGroups/socialNetworkGroups.types";
    import { Config } from "api.types";
    export const SocialNetworkGroupsAPI: (config: Config) => SocialNetworkGroups;
}
declare module "socialNetworkGroups/index" {
    export { SocialNetworkGroupsAPI } from "socialNetworkGroups/socialNetworkGroups";
}
declare module "tasks/contact.types" {
    import { CrudDefaultMethodsType } from "api.types";
    export interface TasksApiType extends CrudDefaultMethodsType {
    }
}
declare module "tasks/methods" {
    import { MethodsBuilder } from "api.types";
    export const TASKS_METHODS: MethodsBuilder;
}
declare module "tasks/tasks" {
    import { Config } from "api.types";
    import { TasksApiType } from "tasks/contact.types";
    export const TasksAPI: (config: Config) => TasksApiType;
}
declare module "tasks/index" {
    export { TasksAPI } from "tasks/tasks";
}
declare module "index" {
    export * from "crm/index";
    export * from "drive/index";
    export * from "users/index";
    export * from "socialNetworkGroups/index";
    export * from "tasks/index";
}