/**
 * Represents a cloud provider.
 */
interface Provider {
    id: string;
    name: string;
}
/**
 * Represents the response for getting a list of cloud providers.
 */
interface GetProviderListResponse {
    providers: Provider[];
}
/**
 * Represents a region.
 */
interface Region {
    id: string;
    name: string;
}
/**
 * Represents the response for getting a list of regions.
 */
interface GetRegionListResponse {
    regions: {
        [provider: string]: Region[];
    };
}
/**
 * Represents the response for getting a list of server sizes.
 */
interface GetServerSizesListResponse {
    sizes: {
        [provider: string]: string[];
    };
}
/**
 * Represents a single app version.
 */
interface AppVersion {
    app_version: string;
    application: string;
}
/**
 * Represents an app with its versions.
 */
interface AppInfo {
    label: string;
    versions: AppVersion[];
}
/**
 * Represents the response for getting a list of apps.
 */
interface GetAppListResponse {
    [appName: string]: AppInfo;
}
/**
 * Represents a package with its versions.
 */
interface Package {
    [version: string]: string;
}
/**
 * Represents a list of available packages and versions.
 */
interface PackageList {
    [packageName: string]: {
        [os: string]: Package;
    };
}
/**
 * Represents the settings options.
 */
interface SettingsOptions {
    [option: string]: string;
}
/**
 * Represents the response for getting a list of settings.
 */
interface GetSettingsListResponse {
    settings: {
        [setting: string]: SettingsOptions;
    };
}
/**
 * Represents a backup frequency option.
 */
interface BackupFrequency {
    id: string;
    label: string;
}
/**
 * Represents a country with its ISO code and name.
 */
interface Country {
    iso: string;
    name: string;
}
/**
 * Represents the response for getting monitoring durations.
 */
interface GetMonitorDurationsResponse {
    durations: string[];
}
/**
 * Represents the response for getting monitor targets.
 */
interface GetMonitorTargetsResponse {
    targets: {
        [provider: string]: string[];
    };
}
/**
 * Represents a server size entry for a provider.
 */
interface ServerSize {
    provider: string;
    sizes: string[];
}
/**
 * Represents a setting entry and its possible values.
 */
interface Setting {
    setting: string;
    values: string[];
}
/**
 * Represents a server monitoring target for a provider.
 */
interface ServerMonitoringTarget {
    provider: string;
    targets: string[];
}

/**
 * Gets a list of available apps and their versions.
 * @returns {Promise<AppInfo[]>} A promise resolving with an array of apps and their versions.
 * @example
 * ```
 * [
 *   {
 *     label: "WordPress",
 *     versions: [
 *       { app_version: "4.7", application: "wordpress" },
 *       ...
 *     ]
 *   },
 *   {
 *     label: "PHP Stack",
 *     versions: [
 *       { app_version: "5.4", application: "phpstack" },
 *       ...
 *     ]
 *   },
 *   ...
 * ]
 * ```
 */
declare function getAppList(): Promise<AppInfo[]>;
/**
 * Gets possible backup frequencies.
 * @returns {Promise<BackupFrequency[]>} A promise resolving with an array of backup frequencies.
 * @example
 * ```
 * [
 *   { "id": "1h", "label": "1 Hour" },
 *   { "id": "3h", "label": "3 Hours" },
 *   ...
 * ]
 * ```
 */
declare function getBackupFrequencies(): Promise<BackupFrequency[]>;
/**
 * Gets the list of countries.
 * @returns {Promise<Country[]>} A promise resolving with the list of countries.
 * @example
 * ```
 * // The API response is an empty object "{}" for countries.
 * []
 * ```
 */
declare function getCountriesList(): Promise<Country[]>;
/**
 * Gets possible monitoring durations.
 * @returns {Promise<string[]>} A promise resolving with monitoring durations.
 * @example
 * ```
 * ["1 Hour", "12 Hours", "1 Day", "7 Days", "1 Month", "6 Months"]
 * ```
 */
declare function getMonitorDurations(): Promise<string[]>;
/**
 * Gets a list of server monitoring graph types.
 * @returns {Promise<ServerMonitoringTarget[]>} A promise resolving with monitoring targets for each provider.
 * @example
 * ```
 * [
 *   { provider: "amazon", targets: ["Idle CPU", "Free Disk (DB)", ...] },
 *   { provider: "do", targets: ["Idle CPU", "Free Disk", ...] },
 *   ...
 * ]
 * ```
 */
declare function getMonitorTargets(): Promise<ServerMonitoringTarget[]>;
/**
 * Gets a list of available packages and their versions.
 * @returns {Promise<PackageList>} A promise resolving with a list of packages and their versions.
 * @example
 * ```
 * {
 *   "php": {
 *     "debian10": {
 *       "7.0": "PHP 7.0",
 *       "7.1": "PHP 7.1",
 *       ...
 *     },
 *     ...
 *   },
 *   "phpConfig": {
 *     "debian10": {
 *       "7.4": ["7.4", "8.0", ...],
 *       ...
 *     },
 *     ...
 *   },
 *   "mysql": {
 *     "debian10": {
 *       "mysql,5.7": "MySQL 5.7",
 *       ...
 *     },
 *     ...
 *   },
 *   "redis": {
 *     "0": "Uninstall",
 *     "latest": "Install"
 *   },
 *   ...
 * }
 * ```
 */
declare function getPackageList(): Promise<PackageList>;
/**
 * Gets a list of available cloud providers.
 * @returns {Promise<Provider[]>} A promise resolving with an array of cloud providers.
 * @example
 * ```
 * [
 *   { "id": "do", "name": "DigitalOcean" },
 *   { "id": "vultr", "name": "Vultr" },
 *   ...
 * ]
 * ```
 */
declare function getProviderList(): Promise<Provider[]>;
/**
 * Gets a list of regions.
 * @returns {Promise<Region[]>} A promise resolving with an array of regions.
 * @example
 * ```
 * [
 *   { "id": "us-east-1", "name": "US N.Virginia" },
 *   { "id": "us-west-1", "name": "California" },
 *   ...
 * ]
 * ```
 */
declare function getRegionList(): Promise<Region[]>;
/**
 * Gets a list of server sizes available.
 * @returns {Promise<ServerSize[]>} A promise resolving with an array of server sizes available for each provider.
 * @example
 * ```
 * [
 *   { provider: "Amazon", sizes: ["Small", "Medium", ...] },
 *   { provider: "DO", sizes: ["512MB", "1GB", ...] },
 *   { provider: "GCE", sizes: ["small", "n1-std-1", ...] },
 *   { provider: "Vultr", sizes: ["768MB", "1GB", ...] },
 *   { provider: "Kyup", sizes: ["1 Core", "2 Cores", ...] },
 *   { provider: "Linode", sizes: ["1GB", "2GB", ...] }
 * ]
 * ```
 */
declare function getServerSizesList(): Promise<ServerSize[]>;
/**
 * Gets a list of available settings and corresponding values.
 * @returns {Promise<Setting[]>} A promise resolving with an array of settings and their possible values.
 * @example
 * ```
 * [
 *   { setting: "timezone", values: ["Pacific/Midway", "Pacific/Samoa", ...] },
 *   { setting: "character_set", values: ["ascii", "greek", ...] },
 *   { setting: "status", values: [" ----", "Off", "On"] },
 *   { setting: "error_reporting", values: [" ----", "E_ALL & ~E_DEPRECATED & ~E_STRICT", ...] },
 *   { setting: "statuses", values: ["disabled", "enabled"] }
 * ]
 * ```
 */
declare function getSettingsList(): Promise<Setting[]>;

/**
 * Represents the request parameters for getting an OAuth access token.
 */
interface GetOAuthAccessTokenRequest {
    /**
     * The email address used to access the Cloudways Platform.
     */
    email: string;
    /**
     * The API key generated on the Cloudways Platform API Section.
     */
    api_key: string;
}
/**
 * Represents the response received after successfully obtaining an OAuth access token.
 */
interface GetOAuthAccessTokenResponse {
    /**
     * The access token used for authorization in subsequent API calls.
     */
    access_token: string;
    /**
     * The type of the token, typically "Bearer".
     */
    token_type: "Bearer";
    /**
     * The number of seconds until the access token expires due to inactivity.
     */
    expires_in: number;
}
declare enum HttpMethod {
    GET = "GET",
    POST = "POST",
    PUT = "PUT",
    DELETE = "DELETE",
    PATCH = "PATCH"
}
interface AuthToken {
    token: string;
    expiration: number;
}

/**
 * Initializes the Cloudways API with user-provided configuration. This function
 * sets up the necessary credentials for subsequent API calls. It accepts the user's
 * email address and an API key generated from the Cloudways platform.
 *
 * This function should be called once to configure the library. After initial setup,
 * the library will automatically handle token renewal, ensuring continued access
 * to the Cloudways API without needing to reinitialize or manually refresh tokens.
 *
 * @param {string} email - The email address used to access the Cloudways Platform.
 * @param {string} apiKey - The API key generated on the Cloudways Platform API Section.
 * @returns {void}
 */
declare function initializeCloudwaysApi(email: string, apiKey: string): void;
/**
 * Make an API call to Cloudways API.
 * @param endpoint - The API endpoint to call.
 * @param method - The HTTP method to use (default: HttpMethod.GET).
 * @param data - The data to send in the request (if applicable).
 * @returns {Promise<any>} - Promise resolving to the API response data.
 * @throws {Error} if the API call fails.
 */
declare function apiCall(endpoint: string, method?: HttpMethod, data?: any): Promise<any>;

/**
 * Represents the response structure for the create project API.
 */
interface CreateProjectResponse {
    /**
     * The project object.
     */
    project: Project;
}
interface Project {
    /**
     * Unique identifier of the project.
     */
    id: string;
    /**
     * Name of the project.
     */
    name: string;
    /**
     * User ID associated with the project.
     */
    user_id: string;
    /**
     * Indicates if this is the default project.
     */
    is_default: string;
    /**
     * Date and time when the project was created.
     */
    created_at: string;
    /**
     * Date and time when the project was last updated.
     */
    updated_at: string;
    /**
     * Image associated with the project, if any.
     */
    image?: string | null;
}
/**
 * Represents the response structure for the get project list API.
 */
interface GetProjectListResponse {
    /**
     * Array of projects.
     */
    projects: Project[];
}
/**
 * Represents the response structure for the update project API.
 */
interface UpdateProjectResponse {
    /**
     * The updated project object.
     */
    project: Project;
}

/**
 * Creates a new project.
 *
 * @param name - The name of the new project.
 * @param appIds - Comma-separated list of app IDs to attach to the project.
 * @returns {Promise<Project>} A promise resolving to the details of the newly created project.
 * @example
 * ```
 * // Example of a successful response:
 * {
 *   "id": "1574",
 *   "name": "Project Name",
 *   "user_id": "12847",
 *   "is_default": "0",
 *   "created_at": "2016-07-13 13:28:58",
 *   "updated_at": "0000-00-00 00:00:00",
 *   "image": null
 * }
 * ```
 */
declare function createProject(name: string, appIds: string): Promise<Project>;
/**
 * Deletes a project by its ID.
 *
 * @param id - The numeric ID of the project to delete.
 * @returns A promise that resolves when the project is deleted.
 */
declare function deleteProject(id: number): Promise<void>;
/**
 * Retrieves a list of all projects.
 *
 * @returns {Promise<Project[]>} A promise resolving to an array of project details.
 * @example
 * ```
 * // Example of a successful response:
 * [
 *   {
 *     "id": "1",
 *     "name": "Default project",
 *     "user_id": "123",
 *     "is_default": "1",
 *     "created_at": "2016-04-14 15:48:35",
 *     "image": "https://example.com/project_pic.png"
 *   }
 * ]
 * ```
 */
declare function getProjectList(): Promise<Project[]>;
/**
 * Updates an existing project.
 *
 * @param id - The numeric ID of the project to update.
 * @param name - The new name of the project.
 * @param appIds - Comma-separated list of app IDs to attach to the project.
 * @returns {Promise<Project>} A promise resolving to the updated project details.
 * @example
 * ```
 * // Example of a successful response:
 * {
 *   "id": "1574",
 *   "name": "Updated Project Name",
 *   "user_id": "12847",
 *   "is_default": "0",
 *   "created_at": "2016-07-13 13:28:58",
 *   "updated_at": "2024-01-01 12:00:00",
 *   "image": null
 * }
 * ```
 */
declare function updateProject(id: number, name: string, appIds: string): Promise<Project>;

interface OperationStatus {
    id: string;
    type: string;
    server_id: string;
    estimated_time_remaining: string;
    frontend_step_number: string;
    status: string;
    is_completed: string;
    parameters?: string;
    message: string;
    app_id: string;
}

/**
 * Gets the status of an operation that is running in the background.
 *
 * @param id - The numeric ID of the operation.
 * @returns {Promise<OperationStatus>} A promise resolving to the operation status details.
 * @example
 * ```
 * {
 *   "operation": {
 *     "id": "596283",
 *     "type": "restarting_server",
 *     "server_id": "50482",
 *     "estimated_time_remaining": "2",
 *     "frontend_step_number": "1",
 *     "status": "Process is initiated",
 *     "is_completed": "0",
 *     "message": "Process is initiated",
 *     "app_id": "0"
 *   }
 * }
 * ```
 */
declare function getOperationStatus(id: string): Promise<OperationStatus>;
declare function getAndWaitForOperationStatusCompleted(operationId: string): Promise<OperationStatus>;

/**
 * Start the process of adding an app to a server.
 * @param {number} serverId Numeric id of the server.
 * @param {string} application App to be installed (e.g., "wordpress", "joomla").
 * @param {string} appLabel Name of the app.
 * @param {string} projectName (Optional) Name of the project to tag the newly created app with.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 *
 * 12345
 *
 * ```
 */
declare function addApp(serverId: number, application: string, appLabel: string, projectName?: string): Promise<OperationStatus>;
/**
 * Clone an app to the same server.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the application.
 * @param {string} appLabel Name of the app.
 * @returns {Promise<OperationStatus>} A promise resolving with the cloned app's id and operation id.
 * @example
 * ```
 * {
 *   "appId": 1111,
 *   "operationId": 12345
 * }
 * ```
 */
declare function cloneApp(serverId: number, appId: number, appLabel: string): Promise<OperationStatus>;
/**
 * Clone an app to another existing server.
 * @param {number} serverId Numeric id of the source server.
 * @param {number} appId Numeric id of the application.
 * @param {number} destinationServerId Numeric id of the destination server.
 * @returns {Promise<OperationStatus>} A promise resolving with the source and destination operation ids along with the cloned app's id.
 * @example
 * ```
 * {
 *   "sourceOperationId": 12345,
 *   "destinationOperationId": 12346,
 *   "appId": 1111
 * }
 * ```
 */
declare function cloneAppToOtherServer(serverId: number, appId: number, destinationServerId: number): Promise<OperationStatus>;
/**
 * Clone a staging app to the same server.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the staging application.
 * @returns {Promise<OperationStatus>} A promise resolving with the cloned staging app's id and operation id.
 * @example
 * ```
 * {
 *   "appId": 1111,
 *   "operationId": 12345
 * }
 * ```
 */
declare function cloneStagingApp(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Clone a staging app to another existing server.
 * @param {number} serverId Numeric id of the source server.
 * @param {number} appId Numeric id of the staging application.
 * @param {number} destinationServerId Numeric id of the destination server.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation ids and the cloned staging app's id.
 * @example
 * ```
 * {
 *   "sourceOperationId": 12345,
 *   "destinationOperationId": 12346,
 *   "appId": 1111
 * }
 * ```
 */
declare function cloneStagingAppToOtherServer(serverId: number, appId: number, destinationServerId: number): Promise<OperationStatus>;
/**
 * Start the process of removing an app.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the application.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 * 12345
 * ```
 */
declare function DeleteApp(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Update the label of an application.
 * @param {number} appId Numeric id of the application.
 * @param {number} serverId Numeric id of the server.
 * @param {string} label New label of the application.
 * @returns {Promise<boolean>} A promise resolving with a boolean indicating the update status.
 * @example
 * ```
 * true
 * ```
 */
declare function updateAppLabel(appId: number, serverId: number, label: string): Promise<boolean>;

/**
 * Represents a server entry.
 */
interface Server {
    id: string;
    label: string;
    status: string;
    tenant_id: string;
    backup_frequency: string;
    local_backups: boolean;
    is_terminated: string;
    created_at: string;
    updated_at: string;
    platform: string;
    cloud: string;
    region: string;
    zone: string | null;
    instance_type: string;
    db_volume_size: string | null;
    data_volume_size: string | null;
    server_fqdn: string;
    public_ip: string;
    volume_size: string;
    master_user: string;
    master_password: string;
    snapshot_frequency: string | null;
    apps: App[];
}
/**
 * Represents an application entry.
 */
interface App {
    id: string;
    label: string;
    application: string;
    app_version: string;
    app_fqdn: string;
    app_user: string;
    app_password: string;
    sys_user: string;
    sys_password: string;
    cname: string;
    mysql_db_name: string;
    mysql_user: string;
    mysql_password: string;
    aliases: string[];
    symlink: string | null;
    server_id: string;
    project_id: string;
    created_at: string;
    webroot: string | null;
    is_csr_available: boolean;
    lets_encrypt: string | null;
    app_version_id: string;
    cms_app_id: string;
}
interface DiskUsageResponse {
    status: boolean;
    operation_id: string;
}

/**
 * Attaches block storage to a server.
 * @param {number} serverId The numeric id of the server.
 * @param {number} storageSize The size of the block storage to attach.
 * @returns {Promise<OperationStatus>} A promise resolving with an object containing the operation id.
 * @example
 * ```
 *
 *  12345
 *
 * ```
 */
declare function attachBlockStorage(serverId: number, storageSize: number): Promise<OperationStatus>;
/**
 * Clones a server.
 * @param {number} sourceServerId The ID of the server to be cloned.
 * @param {string} cloud Cloud provider (do, amazon, vultr, gce, or linode).
 * @param {string} region Cloud region (nyc3, ams2, ...).
 * @param {string} instanceType Instance type (512MB, Small, ...).
 * @param {string} appLabel Name of the app.
 * @param {number} applicationId ID of the application if you want to clone only a single app in the new server.
 * @param {number} dbVolumeSize DB volume size on the server.
 * @param {number} dataVolumeSize Data volume size on the server.
 * @param {number} serverStorage Block storage size (only available for DO servers).
 * @param {boolean} advanceClone Whether to clone server through the advance clone feature.
 * @param {boolean} serverSettings Whether to copy the server's basic and advanced settings, disk optimization settings, security settings, and SMTP settings.
 * @param {boolean} appDomains Whether to copy domain(s) of the application(s) along with the SSL certificate(s) from the source server.
 * @param {boolean} appCrons Whether to copy the scheduled cron jobs for all application(s) from the source server to the new server.
 * @param {boolean} appSupervisorJobs Whether to copy the supervisord cron jobs for all application(s) from the source server to the new server.
 * @param {boolean} appSettings Whether to copy each application's general, php-fpm, varnish, and git configuration settings.
 * @param {boolean} appCredentials Whether to copy the application credentials of each application(s) from the source server to the new server (if exist).
 * @param {boolean} teamAccess Whether to copy the team access settings to the new server.
 * @returns {Promise<OperationStatus>} A promise resolving with an object containing the operation id.
 * @example
 * ```
 *
 *   12345
 *
 * ```
 */
declare function cloneServer(sourceServerId: number, cloud: string, region: string, instanceType: string, appLabel: string, applicationId: number, dbVolumeSize: number, dataVolumeSize: number, serverStorage: number, advanceClone: boolean, serverSettings: boolean, appDomains: boolean, appCrons: boolean, appSupervisorJobs: boolean, appSettings: boolean, appCredentials: boolean, teamAccess: boolean): Promise<OperationStatus>;
/**
 * Starts the process to create a server.
 * @param {string} cloud Cloud provider (do, amazon, vultr, gce, or linode).
 * @param {string} region Cloud region (nyc3, ams2, ...).
 * @param {string} instanceType Instance type (512MB, Small, ...).
 * @param {string} application App to be installed (wordpress, joomla, ...).
 * @param {string} appVersion Version of the app to be installed.
 * @param {string} serverLabel Name of the server.
 * @param {string} appLabel Name of the app.
 * @param {string} projectName Add this parameter when you want to create a project and tag this newly created app with it.
 * @param {number} dbVolumeSize DB volume size on server (Only required for Amazon and GCE).
 * @param {number} dataVolumeSize Data volume size on server (Only required for Amazon and GCE).
 * @returns {Promise<Server>} A promise resolving with the server object.
 * @example
 * ```
 * {
 *     "id" : "50710",
 *     "label" : "sadf",
 *     "status" : "",
 *     "tenant_id" : "1",
 *     "backup_frequency" : "1",
 *     "local_backups" : "no",
 *     "is_terminated" : "0",
 *     "created_at" : "2016-07-13 15:19:25",
 *     "updated_at" : "2016-07-13 15:19:25",
 *     "cloud" : "do",
 *     "region" : "lon1",
 *     "zone" : null,
 *     "instance_type" : "512MB",
 *     "db_volume_size" : null,
 *     "data_volume_size" : null,
 *     "server_fqdn" : "12847-50710.cloudwaysapps.com",
 *     "public_ip" : "",
 *     "volume_size" : "20",
 *     "master_user" : "asdfasdf",
 *     "master_password" : "asdfasdf",
 *     "platform" : "debian8",
 *     "ssh_keys" : [ ],
 *     "addons" : [ ],
 *     "operations" : [ {
 *       "id" : "596406",
 *       "type" : "add_server",
 *       "server_id" : "50710",
 *       "estimated_time_remaining" : "7",
 *       "frontend_step_number" : "1",
 *       "status" : "Process is initiated",
 *       "is_completed" : "0",
 *       "message" : "Process is initiated"
 *     } ]
 *   }
 * ```
 */
declare function createServer(cloud: string, region: string, instanceType: string, application: string, appVersion: string, serverLabel: string, appLabel: string, projectName: string, dbVolumeSize: number, dataVolumeSize: number): Promise<Server>;
/**
 * Starts the process to remove a server.
 * @param {number} serverId Numeric id of the server to be removed.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 *
 *   12345
 *
 * ```
 */
declare function deleteServer(serverId: number): Promise<OperationStatus>;
/**
 * Initiates a fetch disk usage operation for a server.
 * @param {number} serverId Numeric id of the server.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 * {
 *   "status": true,
 *   "operation_id": "ec7a2d1a-0a3d-4ed9-9523-315875618f54"
 * }
 * ```
 */
declare function getDiskUsage(serverId: number): Promise<OperationStatus>;
/**
 * Gets the list of servers.
 * @returns {Promise<Server[]>} A promise resolving with an array of server entries.
 * @example
 * ```
 * [
 *   {
 *     id: "50482",
 *     label: "My Live Server",
 *     status: "running",
 *     tenant_id: "1",
 *     backup_frequency: "1",
 *     local_backups: false,
 *     is_terminated: "0",
 *     created_at: "2016-07-11 11:41:31",
 *     updated_at: "2016-07-13 14:07:47",
 *     platform: "debian8",
 *     cloud: "do",
 *     region: "lon1",
 *     zone: null,
 *     instance_type: "512MB",
 *     db_volume_size: null,
 *     data_volume_size: null,
 *     server_fqdn: "11111-50482.cloudwaysapps.com",
 *     public_ip: "11.62.111.11",
 *     volume_size: "20",
 *     master_user: "master_username",
 *     master_password: "password",
 *     snapshot_frequency: null,
 *     apps: [
 *       {
 *         id: "131933",
 *         label: "dsf",
 *         application: "wordpressmu",
 *         app_version: "4.5.2",
 *         app_fqdn: "wordpressmu-1442-50482-131933.cloudwaysapps.com",
 *         app_user: "user@domain.com",
 *         app_password: "asdfasdf",
 *         sys_user: "sys-user",
 *         sys_password: "password",
 *         cname: "",
 *         mysql_db_name: "password",
 *         mysql_user: "password",
 *         mysql_password: "password",
 *         aliases: [],
 *         symlink: null,
 *         server_id: "50482",
 *         project_id: "1574",
 *         created_at: "2016-07-11 11:41:31",
 *         webroot: null,
 *         is_csr_available: true,
 *         lets_encrypt: null,
 *         app_version_id: "545",
 *         cms_app_id: "23"
 *       }
 *     ]
 *   }
 * ]
 * ```
 */
declare function getServersList(): Promise<Server[]>;
/**
 * Restarts the server.
 * @param {number} serverId Numeric id of the server to be restarted.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 *
 *   12345
 *
 * ```
 */
declare function restartServer(serverId: number): Promise<OperationStatus>;
/**
 * Scales block storage for a DigitalOcean server.
 * @param {number} serverId Numeric id of the server.
 * @param {number} storageSize New block storage size.
 * @returns {Promise<number>} A promise resolving with the operation id.
 * @example
 * ```
 *
 *   12345
 *
 * ```
 */
declare function scaleBlockStorage(serverId: number, storageSize: number): Promise<OperationStatus>;
/**
 * Scales volume size for Amazon and GCE servers.
 * @param {number} serverId Numeric id of the server.
 * @param {number} volumeSize New volume size.
 * @param {string} volumeType Volume type.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 *
 *    12345
 *
 * ```
 */
declare function scaleVolumeSize(serverId: number, volumeSize: number, volumeType: string): Promise<OperationStatus>;
/**
 * Starts the server.
 * @param {number} serverId Numeric id of the server.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 *
 *  12345
 *
 * ```
 */
declare function startServer(serverId: number): Promise<OperationStatus>;
/**
 * Stops the server.
 * @param {number} serverId Numeric id of the server.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 *
 *  12345
 *
 * ```
 */
declare function stopServer(serverId: number): Promise<OperationStatus>;
/**
 * Update server label.
 * @param {number} serverId Numeric id of the server.
 * @param {string} label New label of the server.
 * @returns {Promise<{ status: boolean }>} A promise resolving with the status indicating success.
 * @example
 * ```
 * {
 *     "status": true
 * }
 * ```
 */
declare function updateServerLabel(serverId: number, label: string): Promise<{
    status: boolean;
}>;
/**
 * Upgrade server instance type.
 * @param {number} serverId Numeric id of the server.
 * @param {string} instanceType New instance type (e.g., "512MB", "Small").
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 * @example
 * ```
 *
 *  12345
 *
 * ```
 */
declare function upgradeServer(serverId: number, instanceType: string): Promise<OperationStatus>;

/**
 * Create an SSH key for a server.
 * @param {number} serverId Numeric id of the server.
 * @param {string} sshKeyName Label for the SSH key.
 * @param {string} sshKey The SSH key.
 * @param {number} appCredsId Numeric id of the App Credentials (required for app level SSH keys).
 * @returns {Promise<number>} A promise resolving with the id of the created SSH key.
 * @example
 * ```
 * 1234
 * ```
 */
declare function createSSHKey(serverId: number, sshKeyName: string, sshKey: string, appCredsId: number): Promise<number>;
/**
 * Delete an SSH key from a server.
 * @param {number} serverId Numeric id of the server.
 * @param {number} sshKeyId Numeric id of the SSH key to delete.
 * @returns {Promise<void>} A promise resolving when the SSH key is successfully deleted.
 */
declare function deleteSSHKey(serverId: number, sshKeyId: number): Promise<void>;
/**
 * Update an SSH key on a server.
 * @param {number} serverId Numeric id of the server.
 * @param {number} sshKeyId Numeric id of the SSH key to update.
 * @param {string} sshKeyName New label for the SSH key.
 * @returns {Promise<void>} A promise resolving when the SSH key is successfully updated.
 */
declare function updateSSHKey(serverId: number, sshKeyId: number, sshKeyName: string): Promise<void>;

/**
 * Get server bandwidth usage or disk size per application.
 * @param {number} serverId Numeric id of the server.
 * @param {string} type Possible values are "bw" for bandwidth usage of the server or "db" for application size on disk.
 * @returns {Promise<{ name: string, datapoint: [number, number][], type: string }[]>} A promise resolving with the bandwidth usage or disk size per application.
 */
declare function getServerSummary(serverId: number, type: string): Promise<{
    name: string;
    datapoint: [number, number][];
    type: string;
}[]>;
/**
 * Get server usage.
 * @param {number} serverId Numeric id of the server.
 * @returns {Promise<OperationStatus>} A promise resolving with the operation id.
 */
declare function getServerUsage(serverId: number): Promise<OperationStatus>;
/**
 * Get application disk usage.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the app.
 * @param {string} type String type (summary, disk, db, etc.).
 * @returns {Promise<any>} A promise resolving with the application disk usage data.
 */
declare function getApplicationDiskUsage(serverId: number, appId: number, type: string): Promise<any>;
/**
 * Get application disk usage graph (Deprecated).
 * @param {number} serverId Numeric id of the server.
 * @param {string} appId System user of the application.
 * @param {string} timezone String of the server timezone.
 * @param {number} target String of the target (cpuiddle, memory, etc.).
 * @param {number} duration Integer of the duration.
 * @returns {Promise<any>} A promise resolving with the application disk usage graph data.
 */
declare function getApplicationDiskUsageGraph(serverId: number, appId: string, timezone: string, target: number, duration: number): Promise<any>;
/**
 * Get application traffic analytics.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the app.
 * @param {string} duration String duration (e.g., "15m", "30m", "1h", "1d").
 * @param {string} resource String type ("top_ips", "top_bots", "top_urls", "top_statuses").
 * @returns {Promise<any>} A promise resolving with the application traffic analytics data.
 */
declare function getApplicationTrafficAnalytics(serverId: number, appId: number, duration: string, resource: string): Promise<any>;
/**
 * Get application traffic details.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the app.
 * @param {string} from Start time in the format "DD/MM/YYYY HH:mm".
 * @param {string} until End time in the format "DD/MM/YYYY HH:mm".
 * @param {string[]} resourceList Array of resources returned from the traffic call (e.g., ["127.0.0.1", "192.168.1.1"]).
 * @returns {Promise<any>} A promise resolving with the application traffic details.
 */
declare function getApplicationTrafficDetail(serverId: number, appId: number, from: string, until: string, resourceList: string[]): Promise<any>;
/**
 * Get PHP information.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the app.
 * @param {string} duration String duration (e.g., "15m", "30m", "1h", "1d").
 * @param {string} resource String type ("url_durations", "processes", "slow_pages").
 * @returns {Promise<any>} A promise resolving with the PHP information.
 */
declare function getPHPInformation(serverId: number, appId: number, duration: string, resource: string): Promise<any>;
/**
 * Get MySQL information.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the app.
 * @param {string} duration String duration (e.g., "15m", "30m", "1h", "1d").
 * @param {string} resource String resource ("running_queries", "slow_queries").
 * @returns {Promise<any>} A promise resolving with the MySQL information.
 */
declare function getMySQLInformation(serverId: number, appId: number, duration: string, resource: string): Promise<any>;
/**
 * Get application cron information.
 * @param {number} serverId Numeric id of the server.
 * @param {number} appId Numeric id of the app.
 * @returns {Promise<any>} A promise resolving with the application cron information.
 */
declare function getApplicationCron(serverId: number, appId: number): Promise<any>;

/**
 * Search for queries in the Knowledge Base.
 * @param {string} query The string to search in the Knowledge Base.
 * @returns {Promise<{ articles: { guid: string, post_title: string }[], articles_found: number, status: number }>} A promise resolving with the search results.
 */
declare function searchKnowledgeBase(query: string): Promise<{
    articles: {
        guid: string;
        post_title: string;
    }[];
    articles_found: number;
    status: number;
}>;

/**
 * Represents the response received after activating an addon on account level.
 */
interface ActivateAddonAccountLevelResponse {
    /**
     * A message indicating the success or result of the activation process.
     */
    message: string;
    /**
     * Additional information about the activated addon, if applicable.
     */
    sub: {
        /**
         * The ID of the user addon.
         */
        id_user_addons: string;
        /**
         * The status of the addon activation.
         */
        status: string;
        /**
         * The ID of the package associated with the addon, if any.
         */
        id_package: number | string | null;
    };
}
/**
* Represents the response received after deactivating an addon.
*/
interface DeactivateAnAddonResponse {
    /**
     * A message indicating the success or result of the deactivation process.
     */
    message: string;
    /**
     * Additional information about the deactivated addon, if applicable.
     */
    sub: {
        /**
         * The ID of the user addon.
         */
        id_user_addons: string;
        /**
         * The status of the addon deactivation.
         */
        status: number;
    };
}
interface AddonList {
    id: string;
    label: string;
    custom_field_1: string | null;
    name: string;
    external_link: string;
    vendor: string;
    binding: string;
    form: string;
    incompatible: number[] | null;
    view_type: string;
    sort_order: string;
    packages: {
        [key: string]: {
            id_package: string;
            id_addons: string;
            package_name: string;
            period: string;
            package_price: string;
            addon_limit: string;
            sort_order: string;
        };
    };
}
interface AddonsListResponse {
    addons: {
        [key: string]: AddonList;
    };
}
/**
* Interface for the response of upgrading an addon package.
*/
interface UpgradeAddonResponse {
    message: string;
    sub: {
        id_user_addons: string;
        status: string;
        id_package: string;
    };
}
/**
 * Interface for the response containing domain details.
 */
interface ElasticEmailDomainsResponse {
    status: boolean;
    data: {
        domains: {
            domain: string;
            spf: boolean;
            mx: boolean;
            dkim: boolean;
            dmarc: boolean;
            tracking: boolean;
        }[];
    };
}
/**
 * Interface for the response to verify elastic email domain
 */
interface verifyEmailDomainResponse {
    status: boolean;
    data: {
        domain: string;
        spf: boolean;
        mx: boolean;
        dkim: boolean;
        dmarc: boolean;
        tracking: boolean;
    };
}

/**
 * Activates an add-on on a specified server, especially applicable for SMTP add-ons.
 * @param {number} serverId - The numeric ID of the server where the add-on will be activated.
 * @param {number} addonId - The numeric ID of the add-on to be activated.
 * @param {string} username - The username required for SMTP add-ons.
 * @param {string} password - The password required for SMTP add-ons.
 * @param {string} mode - The mode required for SMTP add-ons. Allowed values are 'enable' or 'update'.
 * @param {string} provider - The SMTP provider to be selected.
 * @param {string} host - The host required for SMTP add-ons.
 * @param {string} port - The port required for SMTP add-ons.
 * @returns {Promise<void>} A promise that resolves when the add-on is successfully activated.
 * @example
 * ```
 * []
 *
 * ```
 */
declare function activateAddOnServer(serverId: number, addonId: number, username: string, password: string, mode: string, provider: string, host: string, port: string): Promise<void>;
/**
 * Activates an addon on the account level.
 * @param {number} addonId - The numeric ID of the addon to be activated.
 * @param {number} packageId - The package ID. Not necessary in case of SMTP addon.
 * @returns {Promise<ActivateAddonAccountLevelResponse>} A promise that resolves to the response containing information about the activated addon.
 * @example
 * {
  "message" : "Your Own SMTP has been successfully enabled.",
  "sub" : {
    "id_user_addons" : "1234",
    "status" : "1",
    "id_package" : null
  }
}
 */
declare function activateAddonOnAccountLevel(addonId: number, packageId: number): Promise<ActivateAddonAccountLevelResponse>;
/**
 * Requests an addon for a specific application.
 * @param {number} addonId - The numeric ID of the addon to be requested.
 * @param {number} serverId - The numeric ID of the server where the application resides.
 * @param {number} appId - The numeric ID of the application to which the addon will be added.
 * @param {number} version - The desired version of the application. Required only for Application Upgradation Add-on.
 * @returns {Promise<void>} A promise that resolves when the addon request is successful.
 * @example
 * ```
 * []
 *
 * ```
 */
declare function addonRequestForApplication(addonId: number, serverId: number, appId: number, version: number): Promise<void>;
/**
 * Deactivates an addon on a specified server.
 * @param {number} serverId - The numeric ID of the server where the addon will be deactivated.
 * @param {number} addonId - The numeric ID of the addon to be deactivated.
 * @returns {Promise<void>} A promise that resolves when the addon deactivation is successful.
 * @example
 * ```
 * []
 *
 * ```
 */
declare function deactivateAddOnYourServer(serverId: number, addonId: number): Promise<void>;
/**
 * Deactivates an addon on the specified server.
 * @param {number} serverId - The ID of the server where the addon will be deactivated.
 * @param {number} addonId - The ID of the addon to deactivate.
 * @returns {Promise<DeactivateAnAddonResponse>} A promise that resolves to the response containing information about the deactivated addon.
 * @example
 * ```
 * {
  "message" : "Your Own SMTP has been successfully deactivated.",
  "sub" : {
    "id_user_addons" : "1234",
    "status" : 0
  }
}
 * ```
 */
declare function deactivateAnAddon(addonId: number): Promise<DeactivateAnAddonResponse>;
/**
 * Retrieve the list of addons from the Cloudways API.
 * @returns {Promise<AddonsListResponse>} - Promise resolving to the list of addons.
 */
declare function getAddonsList(): Promise<AddonsListResponse>;
/**
 * Upgrade an addon package.
 * @param addonId - The numeric id of the addon.
 * @param packageId - The ID of the package to subscribe to.
 * @returns {Promise<UpgradeAddonResponse>} - Promise resolving to the response of upgrading an addon package.
 * @example
 * {
  "message" : "DNS Made Easy request has been successfully received. Our 24/7 support will contact you in a while with further details.",
  "sub" : {
    "id_user_addons" : "1234",
    "status" : "2",
    "id_package" : "7"
  }
}
 *
 */
declare function upgradeAddonPackage(addonId: number, packageId: number): Promise<UpgradeAddonResponse>;
/**
 * Get the list of Elastic Email domains.
 * @returns {Promise<ElasticEmailDomainsResponse>} - Promise resolving to the response containing domain details.
 * @example
 * {
 *   "status": true,
 *   "data": {
 *       "domains": [
 *           {
 *              "domain": "indoorplants.pk",
 *              "spf": false,
 *              "mx": true,
 *              "dkim": false,
 *              "dmarc": false,
 *              "tracking": false
 *           }
 *       ]
 *   }
 * }
 */
declare function getElasticEmailDomains(): Promise<ElasticEmailDomainsResponse>;
/**
 * Verify an Elastic Email domain.
 * @param {string} domain - The domain to verify.
 * @returns {Promise<verifyEmailDomainResponse>} - Promise resolving to the response of verifying the domain.
 * @example
 * {
  "status": true,
  "data": {
      "domain": "indoorplants.pk",
      "spf": false,
      "mx": true,
      "dkim": false,
      "dmarc": false,
      "tracking": false
  }
}
 */
declare function verifyElasticEmailDomain(domain: string): Promise<verifyEmailDomainResponse>;
/**
 * Deletes an Elastic Email domain.
 * @param {string} domain - The domain to delete.
 * @returns {Promise<{status: boolean, message: string}>} - A promise that resolves to an object containing the status and message of the deletion.
 * @example
 * {
  "status": true,
  "message": "Domain successfully deleted"
}
 */
declare function deleteElasticEmailDomain(domain: string): Promise<{
    status: boolean;
    message: string;
}>;

/**
 * Interface for the response of getting application backup status.
 */
interface AppBackupStatusResponse {
    /**
     * Indicates the status of the backup operation.
     */
    status: boolean;
    /**
     * The ID associated with the backup operation.
     */
    operation_id: number;
    /**
     * Index signature to handle unknown properties.
     */
    [key: string]: any;
}
/**
* Interface for the response containing information about App Credentials.
*/
interface AppCredentialsResponse {
    app_creds: {
        id: string;
        sys_password: string;
        sys_user: string;
        ssh_keys: {
            label: string;
            ssh_key_id: string;
        }[];
    }[];
}
/**
 * Interface for the response containing SSH access status.
 */
interface SSHAccessStatusResponse {
    response: {
        ssh_status: {
            [appId: string]: boolean;
        };
    };
}
/**
 * Interface for the response containing application access status.
 */
interface ApplicationAccessStateResponse {
    response: {
        app_status: {
            [appId: string]: boolean;
        };
    };
    status: boolean;
}
/**
 * Interface for the response of getting the cron list.
 */
interface CronListResponse {
    basic: {
        cmd_type: string;
        command: string;
        days: string;
        hours: string;
        minutes: string;
        months: string;
        weekdays: string;
    }[];
    script: string;
}
/**
 * Interface for the response containing FPM settings.
 */
interface FpmSettingsResponse {
    response: {
        fpm_enabled: boolean;
        settings: string;
    };
}
/**
 * Interface for the response containing Varnish settings.
 */
interface VarnishSettingsResponse {
    response: {
        varnish_app_enabled: boolean;
        varnish_enabled: boolean;
        vcl_list: {
            method: string;
            type: string;
            value: string;
        }[];
    };
}
/**
 * Interface for the response to get app setting value
 */
interface getAppSettingResponse {
    status: boolean;
    application_id: string;
    from_address: string | null;
    cors_header: number;
    enforce_https: number;
}
/**
 * Interface for the response to update app geo Ip Header status.
 */
interface UpdateGeoIpHeaderResponse {
    response: {
        geo_ip: {
            [key: string]: boolean;
        };
    };
    status: boolean;
}
/**
 * Interface for the response to update App XMLRPC Header status.
 */
interface UpdateAppXMLRPCHeaderResponse {
    response: {
        xml_rpc: {
            [key: string]: boolean;
        };
    };
    status: boolean;
}

/**
 * Change the access state of an application on a server.
 * @param {number} serverId - The ID of the server.
 * @param {number} appId - The ID of the application.
 * @param {string} state - The new state to set for the application.
 * @returns {Promise<void[]>} - Promise resolving to an empty array upon successful state change.
 * @example
 * []
 */
declare function changeAppAccessState(serverId: number, appId: number, state: string): Promise<void[]>;
/**
 * Retrieve the backup status of an application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the backup status.
 * The backup status object includes a boolean indicating the status and an operation ID
 * And it could sometimes return additional properties
 * @example
 * {
 *   "status": true,
 *   "operation_id": 123456
 * }
 * Operation polling will return backup_dates (An array of restore points available for  the app)
 * and local_backup_exists (a local backup created before restorinig the app)
 */
declare function getAppBackupStatus(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Create new application credentials.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} username - The new username.
 * @param {string} password - The new password.
 * @returns {Promise<{app_cred_id: number}>} - Promise resolving to an object containing the ID of the created app credential.
 * @example
 * {
 *    "app_cred_id": 12345
 * }
 */
declare function createAppCredentials(serverId: number, appId: number, username: string, password: string): Promise<{
    app_cred_id: number;
}>;
/**
 * Delete an application credential.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {number} appCredId - The numeric ID of the application credential to delete.
 * @returns {Promise<void[]>} - Promise indicating the success of the operation.
 * @example
 * []
 * The response is an empty array.
 */
declare function deleteAppCredential(serverId: number, appId: number, appCredId: number): Promise<void[]>;
/**
 * Delete CNAME records associated with an application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID.
 * The operation ID indicates the status of the delete operation.
 * @example
 * {
 *   "operation_id": 123456
 * }
 */
declare function deleteCname(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Delete a local backup associated with an application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID.
 * The operation ID indicates the status of the delete operation.
 * @example
 * {
 *   "operation_id": 123456
 * }
 */
declare function deleteLocalBackup(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Retrieve all available App Credentials.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<AppCredentialsResponse>} - Promise resolving to an object containing information about App Credentials.
 * @example
 * {
 *   "app_creds" : [ {
 *     "id" : "12345",
 *     "sys_password" : "12345678",
 *     "sys_user" : "abc12345",
 *     "ssh_keys" : [ {
 *       "label" : "new ssh key",
 *       "ssh_key_id" : "111"
 *     } ]
 *   } ]
 * }
 */
declare function getAppCredentials(serverId: number, appId: number): Promise<AppCredentialsResponse>;
/**
 * Get the SSH access status for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<SSHAccessStatusResponse>} - Promise resolving to an object containing the SSH access status.
 * @example
 * {
 *   response: {
 *     ssh_status: {
 *       "abcdefgh": true
 *     }
 *   }
 * }
 */
declare function getApplicationSshAccessStatus(serverId: number, appId: number): Promise<SSHAccessStatusResponse>;
/**
 * Get the application access state.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<ApplicationAccessStateResponse>} - Promise resolving to an object containing the application access status.
 * @example
 * {
 *   response: {
 *     app_status: {
 *       "abcdefg": true
 *     }
 *   },
 *   status: true
 * }
 */
declare function getApplicationAccessState(serverId: number, appId: number): Promise<ApplicationAccessStateResponse>;
/**
 * Get the list of cron jobs for the server.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<CronListResponse>} - Promise resolving to an object containing the cron list.
 * @example
 * {
 *   basic: [
 *     {
 *       cmd_type: "php",
 *       command: "test.php",
 *       days: "1",
 *       hours: "0",
 *       minutes: "0",
 *       months: "1",
 *       weekdays: "*"
 *     },
 *     {
 *       cmd_type: "wget",
 *       command: "http://example.com",
 *       days: "1",
 *       hours: "0",
 *       minutes: "0",
 *       months: "1",
 *       weekdays: "*"
 *     }
 *   ],
 *   script: "0 0 1 1 * php test.php"
 * }
 */
declare function getCronList(serverId: number, appId: number): Promise<CronListResponse>;
/**
 * Get the FPM settings for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<FpmSettingsResponse>} - Promise resolving to an object containing the FPM settings.
 * @example
 * {
 *   response: {
 *     fpm_enabled: true,
 *     settings: ";php_admin_flag[log_errors] = on\n;php_admin_value[memory_limit] = 32M\n;php_flag[display_errors] = off\n"
 *   }
 * }
 */
declare function getFpmSettings(serverId: number, appId: number): Promise<FpmSettingsResponse>;
/**
 * Get the Varnish settings for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<VarnishSettingsResponse>} - Promise resolving to an object containing the Varnish settings.
 * @example
 * {
 *   response: {
 *     varnish_app_enabled: true,
 *     varnish_enabled: true,
 *     vcl_list: [
 *       { method: "exclude", type: "url", value: "/index.php" },
 *       { method: "exclude", type: "cookie", value: "/dodo.php" }
 *     ]
 *   }
 * }
 */
declare function getVarnishSettings(serverId: number, appId: number): Promise<VarnishSettingsResponse>;
/**
 * Reset file permissions for the specified application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} ownership - The ownership value to set for the files.
 * @returns {Promise<void>} - Promise that resolves when the file permissions are reset successfully.
 */
declare function resetFilePermissions(serverId: number, appId: number, ownership: string): Promise<void>;
/**
 * Restore app to a previous version from backup
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} time - The time to which the application will be restored.
 * @param {string} type - The type of restoration to perform.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID of the restoration process.
 * @example
 * {
 *   operation_id: 123456
 * }
 */
declare function restoreApp(serverId: number, appId: number, time: string, type: string): Promise<OperationStatus>;
/**
 * Rollback last restore action
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID of the rollback process.
 * @example
 * {
 *   operation_id: 123456
 * }
 */
declare function rollbackRestore(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Initiate a backup process for the specified application on the server.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID of the backup process.
 * @example
 * {
 *   operation_id: 123456
 * }
 */
declare function aplicationBackup(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Update the aliases for an application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string[]} aliases - List of domains like my.example.com, console.example.com.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateAppAlias(serverId: number, appId: number, aliases: string[]): Promise<void>;
/**
 * Update the CNAME for an application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} cname - The new CNAME to set for the application.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID.
 */
declare function updateAppCname(serverId: number, appId: number, cname: string): Promise<OperationStatus>;
/**
 * Update an application credential.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} username - The new username for the credential.
 * @param {string} password - The new password for the credential.
 * @param {number} app_cred_id - The numeric ID of the application credential to update.
 * @returns {Promise<void[]>} - Promise resolving to an empty array upon successful update.
 */
declare function updateAppCredential(serverId: number, appId: number, username: string, password: string, app_cred_id: number): Promise<void[]>;
/**
 * Update the SSH access status for an application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} update_perms_action - The action to update SSH access permissions.
 * @returns {Promise<{ status: boolean; confirmation: boolean }>} - Promise resolving to an object containing the status of the update and confirmation of the action.
 */
declare function updateApplicationSshAccessStatus(serverId: number, appId: number, update_perms_action: string): Promise<{
    status: boolean;
    confirmation: boolean;
}>;
/**
 * Update the cron list for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} crons - The cron schedule(s) to be updated.
 * @param {boolean} is_script - A flag indicating whether the provided cron(s) is a single script or an array of cron objects.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateCronList(serverId: number, appId: number, crons: string, is_script: boolean): Promise<void>;
/**
 * Update the database password for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} password - The new password for the database.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateDBPassword(serverId: number, appId: number, password: string): Promise<void>;
/**
 * Update the FPM settings for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} fpm_setting - The new FPM settings for the application.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateFPMsettings(serverId: number, appId: number, fpm_setting: string): Promise<void>;
/**
 * Update the symlink for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} symlink - The new symlink value.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateSymlink(serverId: number, appId: number, symlink: string): Promise<void>;
/**
 * Update the Varnish settings for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} vcl_list - The Varnish configuration settings.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID.
 */
declare function updateVarnishSettings(serverId: number, appId: number, vcl_list: string): Promise<OperationStatus>;
/**
 * Update the web root directory for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} webroot - The new web root directory path.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateWebroot(serverId: number, appId: number, webroot: string): Promise<void>;
/**
 * Update the CORS (Cross-Origin Resource Sharing) headers for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} corsHeaders - The new CORS headers to be set.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object indicating the status of the operation and the operation ID.
 */
declare function updateCorsHeaders(serverId: number, appId: number, corsHeaders: string): Promise<OperationStatus>;
/**
 * Obtener el estado de redirección WebP de la aplicación.
 * @param {number} serverId - El ID numérico del servidor.
 * @param {number} appId - El ID numérico de la aplicación.
 * @param {string} status - El estado de la redirección WebP. Los valores posibles son "enable" o "disable".
 * @returns {Promise<OperationStatus>} - Promesa que resuelve en un objeto con la propiedad "response" que contiene el ID de operación.
 * @example
 * {
 *   "response": {
 *     "operation_id": 37851
 *   }
 * }
 */
declare function getAplicacionWebPRedirectionStatus(serverId: number, appId: number, status: string): Promise<OperationStatus>;
/**
 * Habilitar o deshabilitar la redirección forzada de HTTPS.
 * @param {number} serverId - El ID numérico del servidor.
 * @param {number} appId - El ID numérico de la aplicación.
 * @param {string} status - El estado de la redirección forzada de HTTPS. Los valores posibles son "enable" o "disable".
 * @returns {Promise<OperationStatus>} - Promesa que resuelve en un objeto con las propiedades "status" y "operation_id".
 * @example
 * {
 *   "status": true,
 *   "operation_id": 12345
 * }
 */
declare function enforceHTTPS(serverId: number, appId: number, status: string): Promise<OperationStatus>;
/**
 * Retrieves the setting values for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<getAppSettingResponse>} - Promise resolving to an object containing the application setting values.
 * @example
 * {
 *   "status": true,
 *   "application_id": "1234",
 *   "from_address": null,
 *   "cors_header": 0,
 *   "enforce_https": 0
 * }
 */
declare function getAppSettingValue(serverId: number, appId: number): Promise<getAppSettingResponse>;
/**
 * Update the status of the GEO IP header for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} status - The status to set for the GEO IP header. Possible values are "enable" or "disable".
 * @returns {Promise<UpdateGeoIpHeaderResponse>} - Promise resolving to an object containing the updated status of the GEO IP header.
 * @example
 * {
  "response" : {
    "geo_ip" : {
      "abcdefg" : true
    }
  },
  "status" : true
}
 */
declare function updateAppGeoIpHeaderStatus(serverId: number, appId: number, status: string): Promise<UpdateGeoIpHeaderResponse>;
/**
 * Update the status of the XML-RPC header for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} status - The status to set for the XML-RPC header. Possible values are "enable" or "disable".
 * @returns {Promise<UpdateAppXMLRPCHeaderResponse>} - Promise resolving to an object containing the updated status of the XML-RPC header.
 * @example
 * {
  "response" : {
    "xml_rpc" : {
      "abcdefg" : true
    }
  },
  "status" : true
}
 */
declare function updateAppXMLRCPheaderStatus(serverId: number, appId: number, status: string): Promise<UpdateAppXMLRPCHeaderResponse>;
/**
 * Update the device detection status for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} status - The status to set for device detection. Possible values are "enable" or "disable".
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the status of the operation.
 * @example
 * {
  "status" : true,
  "operation_id" : 12345
}
 */
declare function updateDeviceDetentionStatus(serverId: number, appId: number, status: string): Promise<OperationStatus>;
/**
 * Update the ignore query string status for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} status - The status to set for ignoring query strings. Possible values are "enable" or "disable".
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the status of the operation.
 * @example
 * {
  "status" : true,
  "operation_id" : 12345
}
 */
declare function updateIgnoreQueryStringStatus(serverId: number, appId: number, status: string): Promise<OperationStatus>;
/**
 * Update the direct PHP execution status for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} status - The status to set for direct PHP execution. Possible values are "enable" or "disable".
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the status of the operation.
 * @example
 * {
  "status" : true,
  "operation_id" : 12345
}
 */
declare function updateDirectPHPExecutionStatus(serverId: number, appId: number, status: string): Promise<OperationStatus>;
/**
 * Update the cron optimizer status for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} status - The status to set for the cron optimizer. Possible values are "enable" or "disable".
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the status of the operation.
 * @example
 * {
  "status" : true,
  "operation_id" : 12345
}
 */
declare function updateCronOptimizerStatus(serverId: number, appId: number, status: string): Promise<OperationStatus>;
/**
 * Update the admin password for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} password - The new password for the application admin.
 * @returns {Promise<OperationStatus>} - Promise resolving to an object containing the operation ID.
 * @example
 * {"response" : { operation_id: 18591 }}
 */
declare function updateAppAdminPassword(serverId: number, appId: number, password: string): Promise<OperationStatus>;

/**
 * Represents the response from the API endpoint for listing application vulnerabilities.
 */
interface ListApplicationVulnerabilitiesResponse {
    status: boolean;
    data: {
        last_fetched_date: string;
        wordpress: {
            name: string;
            slug: string;
            current_version: string;
            type: string;
            is_vulnerable: number;
            vulnerabilities: {
                id: number;
                product_id: number;
                title: string;
                disclosure_date: string;
                product_slug: string;
                product_name: string;
                product_name_premium: string | null;
                product_type: string;
                vuln_type: string;
                cvss_score: number;
                affected_in: string;
                fixed_in: string;
                patched_in_ranges: any[];
                direct_url: string;
            };
            recommendation: string;
            active: number;
            created_at: string;
            updated_at: string;
        };
        themes: {
            name: string;
            slug: string;
            current_version: string;
            type: string;
            is_vulnerable: number;
            vulnerabilities: any[];
            recommendation: string;
            active: number;
            created_at: string;
            updated_at: string;
        }[];
        plugins: {
            name: string;
            slug: string;
            current_version: string;
            type: string;
            is_vulnerable: number;
            vulnerabilities: any[];
            recommendation: string;
            active: number;
            created_at: string;
            updated_at: string;
        }[];
    };
}

/**
 * Retrieves a list of application vulnerabilities.
 * @param {number} appId - The numeric ID of the application.
 * @param {number} serverId - The numeric ID of the server.
 * @returns {Promise<ListApplicationVulnerabilitiesResponse>} A Promise that resolves to the response containing the list of application vulnerabilities.
 * @example
 * {
        "status": true,
        "data": {
            "last_fetched_date": "January 16, 2024",
            "wordpress": {
                "name": "WordPress Core",
                "slug": "wordpress",
                "current_version": "6.4.2",
                "type": "wordpress",
                "is_vulnerable": 1,
                "vulnerabilities": {
                    "id": 9662,
                    "product_id": 8,
                    "title": "WordPress Core All Versions - Unauthenticated Blind Server-Side Request Forgery vulnerability",
                    "disclosure_date": "2022-12-13 06:40:58",
                    "product_slug": "wordpress",
                    "product_name": "WordPress",
                    "product_name_premium": null,
                    "product_type": "WordPress",
                    "vuln_type": "Server Side Request Forgery (SSRF)",
                    "cvss_score": 4,
                    "affected_in": "<= 6.4.2",
                    "fixed_in": "",
                    "patched_in_ranges": [],
                    "direct_url": "https://patchstack.com/database/vulnerability/wordpress/wordpress-6-1-1-unauth-blind-ssrf-vulnerability?_a_id=13"
                },
                "recommendation": "Deactivate and remove the wordpress",
                "active": 1,
                "created_at": "January 16, 2024",
                "updated_at": "2024-01-16T11:10:23.000000Z"
            },
            "themes": [
                {
                    "name": "Twenty Twenty-Four",
                    "slug": "twentytwentyfour",
                    "current_version": "1.0",
                    "type": "theme",
                    "is_vulnerable": 0,
                    "vulnerabilities": [],
                    "recommendation": "",
                    "active": 1,
                    "created_at": "January 16, 2024",
                    "updated_at": "2024-01-16T11:10:23.000000Z"
                },
            ],
            "plugins": [
                {
                    "name": "Breeze",
                    "slug": "breeze",
                    "current_version": "2.1.3",
                    "type": "plugin",
                    "is_vulnerable": 0,
                    "vulnerabilities": [],
                    "recommendation": "",
                    "active": 1,
                    "created_at": "January 16, 2024",
                    "updated_at": "2024-01-16T11:10:23.000000Z"
                },
            ]
        }
}
 */
declare function listApplicationVulnerabilities(appId: number, serverId: number): Promise<ListApplicationVulnerabilitiesResponse>;
/**
 * Initiates a refresh of application vulnerabilities.
 * @param {number} appId - The numeric ID of the application.
 * @param {number} serverId - The numeric ID of the server.
 * @returns {Promise<OperationStatus>} A Promise that resolves to an object containing the status and operation ID of the refresh operation.
 * @example
 * {
        "status": true,
        "operation_id": 525888
    }
 */
declare function refreshApplicationVulnerabilities(appId: number, serverId: number): Promise<OperationStatus>;

/**
 * Represents the response data for Bot Protection Traffic.
 */
interface BotProtectionTrafficResponse {
    logs: {
        ip: string;
        status: string;
        time: number;
        method: string;
        path: string;
        user_agent: string;
        resp_code: number;
        country_name: string;
        id: string;
    }[];
}
/**
 * Represents the response data for Bot Protection Traffic sumary.
 */
interface BotProtectionTrafficSummaryResponse {
    sinceLastDays: number;
    blocked: number;
    total: number;
    summary: {
        day: string;
        total: number;
        allowed: number;
        blocked: number;
    }[];
}
/**
 * Represents the response data for Bot Protection Login Traffic.
 */
interface BotProtectionLoginTrafficResponse {
    logs: {
        ip: string;
        status: "FAILED" | "BLOCKED";
        time: number;
        message: string;
        username: string;
        country_name: string;
        id: string;
    }[];
}
interface BotProtectionLoginTrafficSummaryResponse {
    sinceLastDays: number;
    blocked: number;
    total: number;
    summary: {
        day: string;
        total: number;
        succeeded: number;
        blocked: number;
        failed: number;
    }[];
}
interface BotProtectionBadBotsListResponse {
    blocked: number;
    logs: {
        botname: string;
        visits: number;
        allowed: number;
        blocked: number;
    }[];
}

/**
 * Retrieves the status of bot protection for the application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<{ enable: boolean }>} - A Promise resolving to an object indicating whether bot protection is enabled.
 * @example
 * {
  "enabled": true
}
 */
declare function BotProtectionStatus(serverId: number, appId: number): Promise<{
    enable: boolean;
}>;
/**
   * Retrieves traffic information related to bot protection.
   * @param {number} serverId - The ID of the server to retrieve traffic information from.
   * @param {number} appId - The ID of the application associated with the server.
   * @returns {Promise<BotProtectionTrafficResponse>} - A promise that resolves with the server response containing traffic information.
   * @example
   * {
      "logs": [
          {
              "ip": "127.0.0.1",
              "status": "ALLOWED",
              "time": 1603947151,
              "method": "POST",
              "path": "/wp-cron.php",
              "user_agent": "WordPress/5.4.2; https://woocommerce-18694-398768.cloudwaysstagingapps.com",
              "resp_code": 200,
              "country_name": "-",
              "id": "20201029-5f9a4b17b304643f85e2942e"
          },
   */
declare function BotProtectionTraffic(serverId: number, appId: number): Promise<BotProtectionTrafficResponse>;
/**
   * Retrieves a summary of bot protection traffic for a specific server and application.
   * @param {number} serverId - The ID of the server.
   * @param {number} appId - The ID of the application.
   * @returns {Promise<BotProtectionTrafficSummaryResponse>} A promise that resolves with the summary of bot protection traffic.
   * @example
   * {
        "sinceLastDays": 2,
        "blocked": 0,
        "total": 6,
        "summary": [
            {
                "day": "23-Oct",
                "total": 0,
                "allowed": 0,
                "blocked": 0
            },
   */
declare function BotProtectionTrafficSummary(serverId: number, appId: number): Promise<BotProtectionTrafficSummaryResponse>;
/**
   * Retrieves the bot protection login traffic logs for a specific server and application.
   * @param {number} serverId - The numeric ID of the server.
   * @param {number} appId - The numeric ID of the application.
   * @returns {Promise<BotProtectionLoginTrafficResponse>} A Promise that resolves with the bot protection login traffic logs.
   * @example
   * {
      "logs": [
          {
              "ip": "198.245.49.62",
              "status": "FAILED" or "BLOCKED"
              "time": 1603944210,
              "message": "invalid_username",
              "username": "ahsan",
              "country_name": "Canada",
              "id": "20201029-5f9a3ff0a9f54720f098ea8f"
          },
   */
declare function BotProtectionLoginTraffic(serverId: number, appId: number): Promise<BotProtectionLoginTrafficResponse>;
/**
   * Retrieves the summary of bot protection login traffic for a specific server and application.
   * @param {number} serverId - The numeric ID of the server.
   * @param {number} appId - The numeric ID of the application.
   * @returns {Promise<BotProtectionLoginTrafficSummaryResponse>} A Promise that resolves with the summary of bot protection login traffic.
   * @example
   * {
    "sinceLastDays": 3,
    "blocked": 1,
    "total": 63,
    "summary": [
        {
            "day": "23-Oct",
            "total": 0,
            "succeeded": 0,
            "blocked": 0,
            "failed": 0
        },
   */
declare function BotProtectionLoginTrafficSummary(serverId: number, appId: number): Promise<BotProtectionLoginTrafficSummaryResponse>;
/**
   * Retrieves a list of bad bots for a specific server and application.
   * @param {number} serverId - The ID of the server.
   * @param {number} appId - The ID of the application.
   * @param {number} limit - The maximum number of bad bots to retrieve.
   * @returns {Promise<BotProtectionBadBotsListResponse>} A promise that resolves with the list of bad bots.
   * @example
   * {
    "blocked": 1,
    "logs": [
        {
            "botName": "ApacheBench (ab)",
            "visits": 5233,
            "allowed": 5233,
            "blocked": 0
        }
    ]
  }
   */
declare function BotProtectionBadBotsList(serverId: number, appId: number, limit: number): Promise<BotProtectionBadBotsListResponse>;
/**
 * Retrieves the whitelisted IP addresses for bot protection for a specific server and application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<{ whitelistedIps: string[] }>} A Promise that resolves with the array of whitelisted IP addresses.
 * @example
 * {
  "whitelistedIps": [
      "198.245.49.62"
  ]
}
 */
declare function BotProtectionWhiteListedIps(serverId: number, appId: number): Promise<{
    whitelistedIps: string[];
}>;
/**
 * Retrieves the whitelisted bots for bot protection for a specific server and application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<{ whitelistedBots: string[] }>} A Promise that resolves with the array of whitelisted bots.
 * @example
 * {
  "whitelistedBots": [
      "ApacheBench (ab)"
  ]
}
 */
declare function BotProtectionWhiteListedBots(serverId: number, appId: number): Promise<{
    whitelistedBots: string[];
}>;
/**
 * Activates bot protection for a specific server and application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} A Promise that resolves with the operation ID upon successful activation.
 * @example
 * {
  "operation_id": 12345
}
 */
declare function BotProtectionActivation(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Deactivates bot protection for a specific server and application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} A Promise that resolves with the operation ID upon successful deactivation.
 * @example
 * {
  "operation_id": 12345
}
 */
declare function BotProtectionDeactivation(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Whitelists or removes an IP address from the bot protection whitelist for a specific server and application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} ip - The IP address to whitelist or remove from the whitelist.
 * @param {boolean} status - A boolean indicating whether to whitelist (true) or remove (false) the IP address.
 * @returns {Promise<{ whitelistedBots: string[] }>} A Promise that resolves with the updated list of whitelisted IP addresses.
 * @example
 * {
  "whitelistedIps": [
    "46.101.95.65"
  ]
}
 */
declare function BotProtectionIpWhitelisting(serverId: number, appId: number, ip: string, status: boolean): Promise<{
    whitelistedIps: string[];
}>;
/**
 * Update the whitelist status of a bad bot for bot protection.
 *
 * @param {number} serverId - Numeric ID of the server.
 * @param {number} appId - Numeric ID of the application.
 * @param {string} bot - The name or identifier of the bot to whitelist.
 * @param {boolean} status - The status indicating whether to whitelist or remove from whitelist.
 * @returns {Promise<{ whitelistedBots: string[] }>} A promise that resolves with an object containing the updated list of whitelisted bots.
 * @example
 * {
  "whitelistedBots": [
    "ApacheBench (ab)"
  ]
}
 */
declare function BotProtectionBadBotsWhitelisting(serverId: number, appId: number, bot: string, status: boolean): Promise<{
    whitelistedBots: string[];
}>;
/**
 * Clears the application cache.
 *
 * @param {number} serverId - The numeric id of the server.
 * @param {number} appId - The numeric id of the application.
 * @returns {Promise<OperationStatus>} A promise that resolves to an object containing the status and operation id of the cache purge operation.
 * @example
 * {
  "status": true,
  "operation_id": 12345
}
 */
declare function ClearAppCache(serverId: number, appId: number): Promise<OperationStatus>;

/**
 * interface to get cloudflare details
 */
interface cloudflareDetailsResponse {
    status: boolean;
    dns: {
        app_id: string;
        hostname: string;
        hostname_id: string;
        bandwidth: string;
        status: string;
    }[];
    mode: string | null;
    SP: [];
}
/**
 * interface to setup cloudflare  to you application
 */
interface setupCloudflareResponse {
    status: boolean;
    operation: {
        id: string;
        type: string;
        server_id: string;
        cluster_id: string;
        estimated_time_remaining: string;
        customer_id: string;
        frontend_step_number: string;
        status: string;
        is_completed: string;
        message: string;
        app_id: string;
        app_label: string;
        data: [];
    };
}
/**
 * interface to fetch Record Response
 */
interface FetchTxtRecordsResponse {
    status: boolean;
    txt_records: {
        ownership_verification: {
            status: string;
            txt_name: string;
            txt_value: string;
        };
        ownership_verification_http: {
            type: string;
            name: string;
            value: string;
        };
    };
}
/**
 * interface to get smart cache purge
 */
interface getSmartCachePurgeResponse {
    status: boolean;
    data: {
        deployed: boolean;
    };
}
/**
 * interface to get cloudflare Settings Response
 */
interface getcloudflareSettingsResponse {
    status: boolean;
    data: {
        setting: {
            min_tls_version: string;
            early_hints: string;
            tls_1_3: string;
        };
        custom_metadata: {
            mirage: boolean;
            polish: string;
            webp: boolean;
            minify_js: boolean;
            minify_css: boolean;
            minify_html: boolean;
            scrapeshield: boolean;
            caching: boolean;
            edgecaching: boolean;
            ua_mode: string;
        };
    };
}
/**
 * Represents the response from the API endpoint for getting Cloudflare cache analytics.
 */
interface GetCloudflareCacheAnalyticsResponse {
    status: boolean;
    data: {
        cachStatus: CacheStatus[];
        servedByCloudflare: ServedBy[];
        servedByEdge: ServedBy[];
        servedByOrigin: ServedBy[];
        topAsn: Metric[];
        topContentTypes: Metric[];
        topCountries: Metric[];
        topDeviceTypes: Metric[];
        topEdgeStatusCodes: Metric[];
        topHosts: Metric[];
        topHttpMethods: Metric[];
        topIPs: Metric[];
        topQueryStrings: Metric[];
        topUriPaths: Metric[];
        topUserAgent: Metric[];
        total: Metric[];
        totalServedByCloudflare: Metric[];
        totalServedByOrigin: Metric[];
    }[];
}
/**
 * Represents a cache status object in the Cloudflare cache analytics response.
 */
interface CacheStatus {
    count: number;
    dimensions: {
        cacheStatus: string;
    };
    sum: {
        edgeResponseBytes: number;
    };
}
/**
 * Represents a served by object in the Cloudflare cache analytics response.
 */
interface ServedBy {
    count: number;
    dimensions: {
        ts: string;
    };
    sum: {
        edgeResponseBytes: number;
    };
}
/**
 * Represents a metric object in the Cloudflare cache analytics response.
 */
interface Metric {
    count: number;
    dimensions: {
        metric: string;
    };
    sum: {
        edgeResponseBytes: number;
    };
}
/**
 * Represents the response from the API endpoint for getting Cloudflare security analytics.
 */
interface GetCloudflareSecurityAnalyticsResponse {
    status: boolean;
    data: SecurityAnalyticsData[];
}
/**
 * Represents the data object in the Cloudflare security analytics response.
 */
interface SecurityAnalyticsData {
    eventByServices: MetricWithAvg[];
    seriesByCloudflare: MetricWithoutAvg[];
    seriesByOrigin: MetricWithoutAvg[];
    topAsn: MetricWithoutAvg[];
    topContentType: MetricWithoutAvg[];
    topCountries: MetricWithoutAvg[];
    topDevice: MetricWithoutAvg[];
    topDeviceType: MetricWithoutAvg[];
    topHosts: MetricWithoutAvg[];
    topHttpMethods: MetricWithoutAvg[];
    topIPs: MetricWithoutAvg[];
    topUriPaths: MetricWithoutAvg[];
    topUserAgent: MetricWithoutAvg[];
    topedgeResponseStatus: MetricWithoutAvg[];
    total: MetricWithAvg[];
    totalAction: MetricWithoutAvg[];
}
/**
 * Represents a metric object in the Cloudflare security analytics response that includes 'avg'.
 */
interface MetricWithAvg {
    avg: {
        sampleInterval: number;
    };
    count: number;
    dimensions: {
        metric: string;
        source?: string;
        ts?: string;
        clientASNDescription?: string;
    };
}
/**
 * Represents a metric object in the Cloudflare security analytics response that doesn't include 'avg'.
 */
interface MetricWithoutAvg {
    count: number;
    dimensions: {
        metric: string;
        source?: string;
        ts?: string;
        clientASNDescription?: string;
    };
}

/**
 * Retrieves Cloudflare details for a specific application on a server.
 * @param {number} serverId - The ID of the server.
 * @param {number} appId - The ID of the application.
 * @returns {Promise<cloudflareDetailsResponse>} A promise that resolves to the Cloudflare details for the application.
 * @example
 * {
  "status": true,
  "dns": [
    {
      "app_id": "1234",
      "hostname": "test1.com",
      "hostname_id": "342a8843-d86e-4005-adcb-3gc469e45f69",
      "bandwidth": "1",
      "status": "pending"
    },
    {
      "app_id": "1234",
      "hostname": "test2.com",
      "hostname_id": "342a8843-d86e-4005-adcb-3gc469e45f69",
      "bandwidth": "1",
      "status": "verified"
    },
  ],
  "mode": null,
  "SP": []
}
 */
declare function getCloudflareDetails(serverId: number, appId: number): Promise<cloudflareDetailsResponse>;
/**
 * Sets up Cloudflare for a specific application on a server.
 * @param {number} serverId - The ID of the server.
 * @param {number} appId - The ID of the application.
 * @param {string} domain - The domain to set up Cloudflare for.
 * @returns {Promise<setupCloudflareResponse>} A promise that resolves to the response indicating the setup of Cloudflare for the application.
 * @example
 * {
  "status": true,
  "operation": {
    "id": "12345",
    "type": "create_cf_cdn",
    "server_id": "12345",
    "cluster_id": "0",
    "estimated_time_remaining": "0",
    "customer_id": "123",
    "frontend_step_number": "1",
    "status": "Operation completed",
    "is_completed": "1",
    "message": "Operation completed",
    "app_id": "12345",
    "app_label": "Test App",
    "data": []
  }
}
 */
declare function setUpCloudflareforYourApp(serverId: number, appId: number, domain: string): Promise<setupCloudflareResponse>;
/**
 * Sets up Cloudflare for a specific application on a server.
 * @param {number} serverId - The ID of the server.
 * @param {number} appId - The ID of the application.
 * @param {string} domain - The domain for which to fetch TXT records.
 * @returns {Promise<FetchTxtRecordsResponse>} A promise that resolves to the response containing TXT records for the specified domain.
 * @example
 * {
  "status": true,
  "txt_records": {
    "ownership_verification": {
      "status": "pending",
      "txt_name": "test.com",
      "txt_value": "ca3-2361fd71e07440288be9d6a08d298018"
    },
    "ownership_verification_http": {
      "type": "txt",
      "name": "_cf-custom-hostname.test.com",
      "value": "28acecb5-e2c2-4d87-a2d4-292836786dbf"
    }
  }
}
 */
declare function fetchTxtRecords(serverId: number, appId: number, domain: string): Promise<FetchTxtRecordsResponse>;
/**
 * Deletes specified domains from Cloudflare CDN for a specific application on a server.
 * @param {number} serverId - The ID of the server.
 * @param {number} appId - The ID of the application.
 * @param {string[]} domains - An array of domains to be deleted.
 * @param {number} customerId - The ID of the customer.
 * @returns {Promise<OperationStatus>} A promise that resolves to an object containing the operation ID.
 * @example
 * {
  "operation_id": 12345
}
 */
declare function deleteDomain(serverId: number, appId: number, domains: string[], customerId: number): Promise<OperationStatus>;
/**
 * Transfers specified domains from one application to another application on different servers using Cloudflare CDN.
 * @param {number} serverId - The ID of the source server.
 * @param {number} appId - The ID of the source application.
 * @param {string[]} domains - An array of domains to be transferred.
 * @param {number} dest_server_id - The ID of the destination server.
 * @param {number} dest_app_id - The ID of the destination application.
 * @returns {Promise<OperationStatus>} A promise that resolves to an object containing the operation ID.
 * @example
 * {
  "operation_id": 12345
}
 */
declare function transferDomain(serverId: number, appId: number, domains: string[], dest_server_id: number, dest_app_id: number): Promise<OperationStatus>;
/**
 * Purges the cache for a specified domain associated with a Cloudflare CDN configuration.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application.
 * @param {number} customerId - The ID of the customer.
 * @returns {Promise<OperationStatus>} A promise that resolves to an object containing the operation ID.
 * @example
 * {
  "operation_id": 12345
}
 */
declare function purgeDomain(serverId: number, appId: number, customerId: number): Promise<OperationStatus>;
/**
 * Retrieves DNS query information for a specified domain associated with a Cloudflare CDN configuration.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application.
 * @param {string} domain - The domain for which DNS query information is requested.
 * @returns {Promise<{ status: boolean, primary_domain: boolean, primary_domain_name: string }>} A promise that resolves to an object containing the DNS query information.
 * @example
 * {
  "status": true,
  "primary_domain": true,
  "primary_domain_name": "test.com"
}
 */
declare function getDnsQuery(serverId: number, appId: number, domain: string): Promise<{
    status: boolean;
    primary_domain: boolean;
    primary_domain_name: string;
}>;
/**
 * Verifies TXT records for a specified domain associated with a Cloudflare CDN configuration.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application.
 * @param {string} domain - The domain for which TXT records are to be verified.
 * @returns {Promise<{ status: boolean, domain_status: string }>} A promise that resolves to an object containing the verification status of TXT records for the domain.
 * @example
 * {
    "status": true,
    "domain_status": "activated"
}
 */
declare function verifyTxtRecords(serverId: number, appId: number, domain: string): Promise<{
    status: boolean;
    domain_status: string;
}>;
/**
 * Retrieves the status of the Smart Cache Purge for a specific application on a server.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application.
 * @returns {Promise<getSmartCachePurgeResponse>} A promise that resolves to an object containing the status of the Smart Cache Purge.
 * @example
 * {
    "status": true,
    "data": {
      "deployed": true
      }
    }
 */
declare function getSmartCachePurgeStatus(serverId: number, appId: number): Promise<getSmartCachePurgeResponse>;
/**
 * Configures Smart Cache Purge for a specific application on a server.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application.
 * @returns {Promise<OperationStatus>} A promise that resolves to an object containing the status of the configuration and the operation ID.
 * @example
 * {
      "status": true,
      "operation_id": 106318
    }
 */
declare function configureSmartCachePurge(serverId: number, appId: number): Promise<OperationStatus>;
/**
 * Retrieves Cloudflare settings for a specific application on a server.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application.
 * @returns {Promise<getcloudflareSettingsResponse>} A promise that resolves to the Cloudflare settings response.
 * @example
 * {
      "status": true,
      "data": {
      "setting": {
      "min_tls_version": "1.2",
      "early_hints": "off",
      "tls_1_3": "on"
      },
      "custom_metadata": {
      "mirage": false,
      "polish": "off",
      "webp": false,
      "minify_js": false,
      "minify_css": false,
      "minify_html": false,
      "scrapeshield": false,
      "caching": true,
      "edgecaching": true,
      "ua_mode": "false"
      }
     }
   }
 */
declare function getClouflareSettings(serverId: number, appId: number): Promise<getcloudflareSettingsResponse>;
/**
 * Updates Cloudflare settings for a specific application on a server.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application.
 * @param {boolean} caching - Specifies whether caching is enabled.
 * @param {string} early_hints - The setting for early hints.
 * @param {boolean} edgecaching - Specifies whether edge caching is enabled.
 * @param {string} image_optimization - The setting for image optimization.
 * @param {boolean} minification - Specifies whether minification is enabled.
 * @param {boolean} mobile_optimization - Specifies whether mobile optimization is enabled.
 * @param {boolean} scrapeshield - Specifies whether scrapeshield is enabled.
 * @returns {Promise<OperationStatus>} A promise that resolves to the status and operation ID of the update operation.
 * @example
 * {
          "status": true,
          "operation_id": 12345
          }
 */
declare function updateCloudflareSettings(serverId: number, appId: number, caching: boolean, early_hints: string, edgecaching: boolean, image_optimization: string, minification: boolean, mobile_optimization: boolean, scrapeshield: boolean): Promise<OperationStatus>;
/**
 * Retrieves Cloudflare cache analytics for a specific server and application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {number} mins - The minutes parameter.
 * @returns {Promise<GetCloudflareCacheAnalyticsResponse>} A Promise that resolves with the Cloudflare cache analytics response.
 * @example
 * {
        "status": true,
        "data": [
            {
                "cachStatus": [
                    {
                        "count": 15,
                        "dimensions": {
                            "cacheStatus": "dynamic"
                        },
                        "sum": {
                            "edgeResponseBytes": 200386
                        }
                    },
                ],
                "servedByCloudflare": [
                    {
                        "count": 1,
                        "dimensions": {
                            "ts": "2023-12-31T20:36:00Z"
                        },
                        "sum": {
                            "edgeResponseBytes": 61328
                        }
                    },
                ],
                "servedByEdge": [
                    {
                        "count": 4,
                        "dimensions": {
                            "ts": "2024-01-02T15:00:00Z"
                        },
                        "sum": {
                            "edgeResponseBytes": 21591
                        }
                    },
                ],
                "servedByOrigin": [
                    {
                        "count": 1,
                        "dimensions": {
                            "ts": "2023-12-31T16:00:00Z"
                        },
                        "sum": {
                            "edgeResponseBytes": 1571
                        }
                    },
                ],
                "topAsn": [
                    {
                        "count": 1639,
                        "dimensions": {
                            "clientASNDescription": "CYBERNET-AP Cyber Internet Services Pvt Ltd.",
                            "metric": "9541"
                        },
                        "sum": {
                            "edgeResponseBytes": 31187129
                        }
                    },
                ],
                "topContentTypes": [
                    {
                        "count": 567,
                        "dimensions": {
                            "metric": "js"
                        },
                        "sum": {
                            "edgeResponseBytes": 8552975
                        }
                    },
                ],
                "topCountries": [
                    {
                        "count": 87,
                        "dimensions": {
                            "metric": "US"
                        },
                        "sum": {
                            "edgeResponseBytes": 824561
                        }
                    },
                ],
                "topDeviceTypes": [
                    {
                        "count": 23,
                        "dimensions": {
                            "metric": "mobile"
                        },
                        "sum": {
                            "edgeResponseBytes": 339977
                        }
                    },
                ],
                "topEdgeStatusCodes": [
                    {
                        "count": 48,
                        "dimensions": {
                            "metric": 404
                        },
                        "sum": {
                            "edgeResponseBytes": 1874638
                        }
                    },
                ],
                "topHosts": [
                    {
                        "count": 1891,
                        "dimensions": {
                            "metric": "staging2.thecloudkeeper.io"
                        },
                        "sum": {
                            "edgeResponseBytes": 34314359
                        }
                    }
                ],
                "topHttpMethods": [
                    {
                        "count": 80,
                        "dimensions": {
                            "metric": "POST"
                        },
                        "sum": {
                            "edgeResponseBytes": 31800
                        }
                    },
                ],
                "topIPs": [
                    {
                        "count": 153,
                        "dimensions": {
                            "metric": "149.210.166.197"
                        },
                        "sum": {
                            "edgeResponseBytes": 2242001
                        }
                    },
                ],
                "topQueryStrings": [
                    {
                        "count": 39,
                        "dimensions": {
                            "metric": "?ver=1565817311"
                        },
                        "sum": {
                            "edgeResponseBytes": 65157
                        }
                    },
                ],
                "topUriPaths": [
                    {
                        "count": 1,
                        "dimensions": {
                            "metric": "/blog"
                        },
                        "sum": {
                            "edgeResponseBytes": 810
                        }
                    },
                ],
                "topUserAgent": [
                    {
                        "count": 1,
                        "dimensions": {
                            "metric": "Cloudflare-Purge/2.0"
                        },
                        "sum": {
                            "edgeResponseBytes": 1253
                        }
                    },
                ],
                "total": [
                    {
                        "avg": {
                            "sampleInterval": 2.9593114241001564
                        },
                        "count": 1891,
                        "sum": {
                            "edgeResponseBytes": 34314359
                        }
                    }
                ],
                "totalServedByCloudflare": [
                    {
                        "count": 1057,
                        "sum": {
                            "edgeResponseBytes": 15136193
                        }
                    }
                ],
                "totalServedByOrigin": [
                    {
                        "count": 410,
                        "sum": {
                            "edgeResponseBytes": 7902966
                        }
                    }
                ]
            }
        ]
    }
 */
declare function getClouflareCacheAnalytics(serverId: number, appId: number, mins: number): Promise<GetCloudflareCacheAnalyticsResponse>;
/**
 * Retrieves Cloudflare security analytics for a specific server and application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {number} mins - The number of minutes for which analytics data is requested.
 * @returns {Promise<GetCloudflareSecurityAnalyticsResponse>} A promise that resolves to the response containing Cloudflare security analytics.
 */
declare function getClouflareSecurityAnalytics(serverId: number, appId: number, mins: number): Promise<GetCloudflareSecurityAnalyticsResponse>;

/**
 * Interface representing the response structure for creating an alert channel.
 */
interface CreateAlertChannelResponse {
    integration: {
        id: number;
        name: string;
        user_id: number;
        events: number[];
        config: {
            to?: string;
            url?: string;
        };
        created_at: string;
        updated_at: string | null;
        channel: number;
        is_active: number;
    };
}
/**
 * Interface for the response of getting all alerts.
 */
interface GetAllAlertsResponse {
    alerts: {
        id: number;
        server_id: number;
        app_id: number | null;
        details: {
            subject: string;
            desc: string;
            template_slug: string;
            values: {
                SERVER_LABEL: string;
            };
        };
    }[];
}
/**
 * Interface for the response of the Get list of all Alert Channels API.
 */
interface GetAllAlertChannelsResponse {
    events: AlertEvent[];
    channels: {
        [key: string]: AlertChannel;
    };
}
/**
 * Represents an alert event.
 */
interface AlertEvent {
    id: number;
    name: string;
    type: string;
    level: number;
}
/**
 * Represents an alert channel.
 */
interface AlertChannel {
    name: string;
    call_type: string;
    config?: ChannelConfig;
}
/**
 * Represents the configuration of an alert channel.
 */
interface ChannelConfig {
    url: string;
    content_type?: string;
}
/**
 * Interface to get user's alert channel
 */
interface UserAlertChannel {
    integrations: {
        id: number;
        name: string;
        created_at: string;
        events: number[];
        config: {
            to: string;
        };
        is_active: number;
        channel: number;
    }[];
}
/**
 * Interface to update an alert integration
 */
interface UpdateIntegrationResponse {
    integration: {
        id: number;
        name: string;
        user_id: number;
        events: number[];
        config: {
            to: string;
        };
        created_at: string;
        updated_at: string | null;
        channel: number;
        is_active: number;
    };
}

/**
 * Creates an alert channel.
 *
 * @param {string} name - The name of the alert.
 * @param {string} channel - The integration channel id (e.g., 3 for Slack).
 * @param {number[]} events - An array of event ids that trigger the alert.
 * @param {boolean} is_active - Indicates whether the alert channel is active (true) or inactive (false).
 * @param {string} [to] - The email address (required if mail is chosen as the alert channel).
 * @param {string} [url] - The URL required to hook integrations other than email.
 * @returns {Promise<CreateAlertChannelResponse>} A promise that resolves to an object containing the details of the created alert channel.
 * @example
 * {
  "integration" : {
    "id" : 8888,
    "name" : "2",
    "user_id" : 88,
    "events" : [ 1, 2 ],
    "config" : {
      "to" : "asd@asd.com"
    },
    "created_at" : "2016-10-13 10:02:13",
    "updated_at" : null,
    "channel" : 2,
    "is_active" : 1
  }
}
 */
declare function createAlertChannel(name: string, channel: string, events: number[], is_active: boolean, to?: string, url?: string): Promise<CreateAlertChannelResponse>;
/**
 *Deletes a Cloudways Bot channel.
 *@param {number} channel_id - The id of the channel to be deleted.
 *@returns {Promise<void>}
 */
declare function deleteCloudwaysBotChannel(channel_id: number): Promise<void>;
/**
 * Retrieves the list of all alerts.
 * @returns {Promise<GetAllAlertsResponse>} A promise that resolves with the response containing the list of all alerts.
 * @example
 * {
  "alerts" : [ {
    "id" : 88888,
    "server_id" : 8888,
    "app_id" : null,
    "details" : {
      "subject" : "Disk Inode Alert",
      "desc" : "The available free disk inodes on your server are low.",
      "template_slug" : "inode-full-1",
      "values" : {
        "SERVER_LABEL" : "DEB8_PHP7"
      }
    }
  } ]
}
 */
declare function getAllAlerts(): Promise<GetAllAlertsResponse>;
/**
 * Retrieves the paginated list of alerts.
 *
 * @param {number} lastId - The ID of the last alert from the previous call to get the next set of alerts.
 * @returns {Promise<GetAllAlertsResponse>} A promise that resolves with the response containing the paginated list of alerts.
 * @example{
  "alerts" : [ {
    "id" : 88888,
    "server_id" : 8888,
    "app_id" : null,
    "details" : {
      "subject" : "Disk Inode Alert",
      "desc" : "The available free disk inodes on your server are low.",
      "template_slug" : "inode-full-1",
      "values" : {
        "SERVER_LABEL" : "DEB8_PHP7"
      }
    }
  } ]
}
 */
declare function getPaginatedAlerts(lastId: number): Promise<GetAllAlertsResponse>;
/**
 * Retrieves the list of all alert channels.
 *
 * @returns {Promise<GetAllAlertChannelsResponse>} A promise that resolves with the response containing the list of all alert channels.
 * @example
 * {
  "events" : [ {
    "id" : 1,
    "name" : "Web Stack Health",
    "type" : "CBWebstackHealth",
    "level" : 1
  }, {
    "id" : 2,
    "name" : "Host Health",
    "type" : "HostHealth",
    "level" : 1
  }],
  "channels" : {
    "1" : {
      "name" : "HipChat",
      "call_type" : "web_request",
      "config" : {
        "url" : "https://api.hipchat.com/v2/room/ROOM_ID/notification?auth_token=YOUR_AUTH_TOKEN",
        "content_type" : "application/x-www-form-urlencoded"
      }
    }
 */
declare function getAllAlertChannels(): Promise<GetAllAlertChannelsResponse>;
/**
 * Retrieves the list of user-configured alert integrations.
 * @returns {Promise<UserAlertChannel>} A promise that resolves with an array of user alert channels.
 * @example
 * {
  "integrations" : [ {
    "id" : 44,
    "name" : "John Doe",
    "created_at" : "2016-07-26 14:49:32",
    "events" : [ 1, 2, 5, 6, 7, 8, 9, 10 ],
    "config" : {
      "to" : "john.doe@aol.com"
    },
    "is_active" : 1,
    "channel" : 2
  } ]
}
 */
declare function getUserAlertChannels(): Promise<UserAlertChannel>;
/**
 * Marks all of the alerts as read.
 * @returns {Promise<void>} A promise that resolves when all alerts are marked as read.
 */
declare function markAllAlertsAsRead(): Promise<void>;
/**
 * Marks the specified alert as read.
 * @param {number} alertId - The numeric ID of the alert to mark as read.
 * @returns {Promise<void>} A promise that resolves when the alert is successfully marked as read.
 */
declare function markAlertAsRead(alertId: number): Promise<void>;
/**
 * Updates a CloudwaysBot integration.
 * @param {number} channelId - The numeric ID of the channel to update.
 * @param {string} name - The name of the alert.
 * @param {string} channel - The integration channel ID (e.g., 3 for Slack).
 * @param {number[]} events - An array of event IDs that trigger the alert.
 * @param {boolean} isActive - Specifies if the alert is active (true) or inactive (false).
 * @param {string} to - The email address required if mail is chosen as alert integration.
 * @param {string} url - The URL required to hook integrations other than email.
 * @returns {Promise<UpdateIntegrationResponse>} A promise that resolves with the updated integration data.
 * @example
 * {
  "integration" : {
    "id" : 8888,
    "name" : "2",
    "user_id" : 88,
    "events" : [ 1, 2 ],
    "config" : {
      "to" : "asd@asd.com"
    },
    "created_at" : "2016-10-13 10:02:13",
    "updated_at" : null,
    "channel" : 2,
    "is_active" : 1
  }
}
 */
declare function updateCloudwaysBotIntegration(channelId: number, name: string, channel: string, events: number[], isActive: boolean, to: string, url: string): Promise<UpdateIntegrationResponse>;

/**
 * Represents the response from the API endpoint for listing DNS Made Easy domains.
 */
interface ListDNSMadeEasyDomainsResponse {
    domains: DNSMadeEasyDomain[];
}
/**
 * Represents a DNS Made Easy domain.
 */
interface DNSMadeEasyDomain {
    uid: string;
    name: string;
    query_usage: string;
    status: string;
    nameservers: string[];
}
/**
 * Represents the response from the API endpoint for retrieving DNS Made Easy domain's records.
 */
interface GetDNSMadeEasyDomainRecordsResponse {
    records: DNSRecord[];
}
/**
 * Represents a DNS record in the response from the API endpoint for retrieving DNS Made Easy domain's records.
 */
interface DNSRecord {
    uid: string;
    type: string;
    attributes: {
        ttl: number;
        name: string;
        value: string;
        failed: boolean;
        source: number;
        monitor: boolean;
        failover: boolean;
        hardLink: boolean;
        dynamicDns: boolean;
        gtdLocation: string;
    };
}
interface addRecordToDnsMadeEasyDomainResponse {
    records: {
        type: string;
        attributes: {
            source: number;
            gtdLocation: string;
            ttl: number;
            failover: boolean;
            monitor: boolean;
            hardLink: boolean;
            dynamicDns: boolean;
            failed: boolean;
            name: string;
            value: string;
        };
        uid: string;
        updated_at: string;
        created_at: string;
    }[];
}
interface getCurrentMonthDnsUsageResponse {
    usage: {
        date: string;
        query_usage: number;
    }[];
}

/**
 * Retrieves a list of DNS Made Easy domains.
 * @returns {Promise<ListDNSMadeEasyDomainsResponse>} A Promise that resolves to an object containing an array of DNS Made Easy domains.
 * @example
 * {
  "domains": [
    {
      "uid": "9a9f3e63-ef76-4066-8a65-fcbb71e30bd8",
      "name": "myfirstdomain.com",
      "query_usage": "1.56",
      "status": "Inactive",
      "nameservers": [
        "nameserver1.com"
      ]
    }
  ]
}
 */
declare function listDNSMadeEasyDomains(): Promise<ListDNSMadeEasyDomainsResponse>;
/**
 * Adds DNS Made Easy domains.
 * @param {string[]} names - An array of domain names to add.
 * @returns {Promise<{ message: string }>} A Promise that resolves to an object containing a message indicating the success of the operation.
 * @example
 * {
  "message": "Domains Created Successfully"
}
 */
declare function AddDNSMadeEasyDomains(names: string[]): Promise<{
    message: string;
}>;
/**
 * Deletes DNS Made Easy domains.
 * @param {string[]} ids - An array of domain IDs to delete.
 * @returns {Promise<{ deleted: boolean, message: string }>} A Promise that resolves to an object containing a boolean indicating whether the domains were deleted successfully and a message describing the outcome.
 * @example
 * {
  "deleted": true,
  "message": "Domains Deleted Successfully"
}
 */
declare function DeleteDNSMadeEasyDomains(ids: string[]): Promise<{
    deleted: boolean;
    message: string;
}>;
/**
 * Retrieves the status of a DNS Made Easy domain.
 * @param {string} uid - The unique identifier of the domain.
 * @returns {Promise<{ status: string }>} A Promise that resolves to an object containing the status of the domain.
 * @example
 * {
  "status": "Inactive"
}
 */
declare function getDNSMadeEasyDomainsStatus(uid: string): Promise<{
    status: string;
}>;
/**
 * Retrieves DNS Made Easy domain's records.
 * @param {string} domainId - Domain ID.
 * @returns {Promise<GetDNSMadeEasyDomainRecordsResponse>} The response containing the DNS records.
 * @example
 * {
  "records": [
    {
      "uid": "9aaaae08-57ab-4a63-944f-1ccf15791aa2",
      "type": "MX",
      "attributes": {
        "ttl": 3600,
        "name": "",
        "value": "192.168.1.14",
        "failed": false,
        "source": 1,
        "monitor": false,
        "failover": false,
        "hardLink": false,
        "dynamicDns": false,
        "gtdLocation": "DEFAULT"
      }
    },
  ]
}
 */
declare function getDNSMadeEasyDomainsRecords(domainId: string): Promise<GetDNSMadeEasyDomainRecordsResponse>;
/**
 * Adds records to a DNS Made Easy domain.
 * @param {string} domainId - The ID of the domain.
 * @param {any[]} records - The records to add to the domain.
 * @returns {Promise<addRecordToDnsMadeEasyDomainResponse>} A promise that resolves with the response indicating the success of the operation.
 * @example
 * {
  "records": [
    {
      "type": "A",
      "attributes": {
      "source": 1,
      "gtdLocation": "DEFAULT",
      "ttl": 3600,
      "failover": false,
      "monitor": false,
      "hardLink": false,
      "dynamicDns": false,
      "failed": false,
      "name": "test",
      "value": "192.168.31.2"
      },
    "uid": "9ad24517-8d56-4ad5-9665-bc4492d25351",
    "updated_at": "2023-12-11T07:15:29.000000Z",
    "created_at": "2023-12-11T07:15:29.000000Z"
    }
  ]
}
 */
declare function AddRecordToDnsMadeEasyDomain(domainId: string, records: any[]): Promise<addRecordToDnsMadeEasyDomainResponse>;
/**
 * Deletes records from a DNS Made Easy domain.
 * @param {string} domainId - The ID of the domain.
 * @param {string[]} records_id - The IDs of the records to delete.
 * @returns {Promise<{ status: boolean, message: string }>} A promise that resolves with the status and message indicating the success of the operation.
 * @example
 *  {
  "status": true,
  "message": "Record Deleted Successfully."
}
 */
declare function DeleteRecordfromDnsMadeEasyDomain(domainId: string, records_id: string[]): Promise<{
    status: boolean;
    message: string;
}>;
/**
 * Updates a record of a DNS Made Easy domain.
 * @param {string} domainId - The ID of the domain.
 * @param {string} record_id - The ID of the record to update.
 * @param {object} record - The updated record object.
 * @returns {Promise<{ status: boolean, message: string }>} A promise that resolves with the status and message indicating the success of the operation.
 * @example
 * {
  "status": true,
  "message": "Record Updated Successfully."
}
 */
declare function updateRecordOfDnsMadeEasyDomain(domainId: string, record_id: string, record: object): Promise<{
    status: boolean;
    message: string;
}>;
/**
 * Retrieves the current month's DNS Made Easy domain usage.
 * @param {string} domainId - The ID of the domain.
 * @returns {Promise<getCurrentMonthDnsUsageResponse>} A promise that resolves with the current month's DNS usage response.
 * @example
 * {
  usage: [
    {
      date: "2023-12-01",
      query_usage: 20,
    },
    {
      date: "2023-12-02",
      query_usage: 30,
    },
  ],
}
 */
declare function GetCurrentMonthDnsMadeEasyDomainUsage(domainId: string): Promise<getCurrentMonthDnsUsageResponse>;

/**
 * interface to get git deployment history response
 */
interface gitDeploymentHistoryResponse {
    logs: {
        git_url: string;
        branch_name: string;
        customer_id: string;
        path: null | string;
        result: string;
        datetime: string;
        description: string;
    }[];
}

/**
 * Generates a SSH key for Git on the specified server and application.
 *
 * @param {number} serverId - Numeric ID of the server.
 * @param {number} appId - Numeric ID of the application.
 * @returns {Promise<void>} A promise that resolves when the SSH key is generated.
 */
declare function generateGitSsh(serverId: number, appId: number): Promise<void>;
/**
 * Retrieves the list of branch names from the Git repository associated with the specified server and application.
 *
 * @param {number} serverId - Numeric ID of the server.
 * @param {number} appId - Numeric ID of the application.
 * @param {string} gitUrl - Git repository address.
 * @returns {Promise<{ branches : string[]}>} A promise that resolves with an array of branch names.
 * @example
 * {
  "branches" : [ "master", "staging" ]
}
 */
declare function getBranchNames(serverId: number, appId: number, gitUrl: string): Promise<{
    branches: string[];
}>;
/**
 * Retrieves the recent deployment history for a Git repository.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<gitDeploymentHistoryResponse>} A Promise that resolves to an object containing the deployment history.
 * @example
 * {
  "logs" : [ {
    "git_url" : "git@bitbucket.org:user/difftest.git",
    "branch_name" : "master",
    "customer_id" : "5",
    "path" : null,
    "result" : "1",
    "datetime" : "05, 07, 2016 - 13:09",
    "description" : "running"
  } ]
}
 */
declare function getGitDeploymentHistory(serverId: number, appId: number): Promise<gitDeploymentHistoryResponse>;
/**
 * Retrieves the SSH key for Git deployment.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<{ key: string }>} A Promise that resolves to an object containing the SSH key.
 * @example
 * {
  "key" : "aeiou"
}
 */
declare function getGitSsh(serverId: number, appId: number): Promise<{
    key: string;
}>;
/**
 * Initiates a Git clone operation.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} git_url - The Git repository URL.
 * @param {string} branch_name - The name of the branch to clone.
 * @param {string} deploy_path - The path where the repository will be deployed.
 * @returns {Promise<OperationStatus>} A Promise that resolves to an object containing the operation ID.
 * @example
 * {
  "operation_id" : 12345
}
 */
declare function startGitClone(serverId: number, appId: number, git_url: string, brach_name: string, deploy_path: string): Promise<OperationStatus>;
/**
 * Initiates a Git pull operation.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} branch_name - The name of the branch to pull.
 * @param {string} deploy_path - The path where the repository will be deployed.
 * @returns {Promise<OperationStatus>} A Promise that resolves to an object containing the operation ID.
 * @example
 * {
  "operation_id" : 12345
}
 */
declare function startGitPull(serverId: number, appId: number, brach_name: string, deploy_path: string): Promise<OperationStatus>;

/**
 * Interface to get Safe Updates List Response
 */
interface getSafeUpdatesListResponse {
    status: true;
    updates_list: {
        app_id: string;
        is_enable: string;
        update_slot: string;
        update_day: string;
        core: string;
        plugins: {
            require: number;
        };
        theme: {
            require: number;
        };
    }[];
}
/**
 * Represents the SafeUpdates settings for an application.
 */
interface SafeUpdatesSettings {
    settings: {
        id: string;
        app_id: string;
        is_update_enable: string;
        update_list: {
            plugin: string[];
            theme: string[];
            core: string;
        };
        available_update_list: {
            plugin: string[];
            theme: string[];
            core: string;
            themes_with_versions: string[];
            plugins_with_versions: string[];
        };
        update_slot: string;
        update_day: string;
        updated_at: string;
        notification_email: string;
        pre_notification: string;
        successful_updates: string;
        failed_updates: string;
    };
    status: boolean;
}
/**
 * interface to get safeupdates schedule
 */
interface SafeUpdatesShedule {
    status: boolean;
    updates_list: {
        core: string;
        themes: {
            selected: number;
            updated: number;
        };
        plugins: {
            selected: number;
            updated: number;
        };
    };
}
interface SafeUpdatesHistory {
    status: boolean;
    history: SafeUpdate[];
}
interface SafeUpdate {
    id: string;
    app_id: string;
    message: string;
    updates: {
        core: string;
        themes: {
            selected: number;
            updated: number;
        };
        plugins: {
            selected: number;
            updated: number;
        };
    };
    status: string;
    type: string;
    created_at: string;
    update_date: string;
    reason: string;
    case: number;
}

/**
 * Retrieves safe updates details for a specific server and application.
 * @param {number} server_id - The numeric ID of the server.
 * @param {number} app_id - The numeric ID of the application.
 * @returns {Promise<OperationStatus>} A promise that resolves with the status and operation ID of the safe updates.
 * @example
 * {
      "status": true,
      "operation_id":12345
}
 */
declare function getSafeUpdatesDetail(server_id: number, app_id: number): Promise<OperationStatus>;
/**
 * Updates safe updates for a specific server and application.
 * @param {number} server_id - The numeric ID of the server.
 * @param {number} app_id - The numeric ID of the application.
 * @param {string} core - The version of the core to update.
 * @param {any[]} plugin - An array of plugins to update.
 * @param {any[]} theme - An array of themes to update.
 * @returns {Promise<OperationStatus>} A promise that resolves with the status and operation ID of the safe updates.
 * @example
 * {
    "status": true,
    "operation_id":12345
  }
 */
declare function UpdateSafeupdates(server_id: number, app_id: number, core: string, plugin: any[], theme: any[]): Promise<OperationStatus>;
/**
 * Retrieves the status of safe updates for a specific server and application.
 * @param {number} server_id - The ID of the server.
 * @param {number} app_id - The ID of the application.
 * @returns {Promise<{ status: boolean, data: { is_active: boolean } }>} A Promise that resolves with the status of safe updates and whether they are active or not.
 * @example
 * {
  "status": true,
  "data": {
      "is_active": true
  }
}
 */
declare function getSafeUpdatesStatus(server_id: number, app_id: number): Promise<{
    status: boolean;
    data: {
        is_active: boolean;
    };
}>;
/**
 * Updates the status of safe updates for a specific application.
 * @param {string} appType - The type of the application.
 * @param {number} app_id - The ID of the application.
 * @param {string} app_name - The name of the application.
 * @param {string} enable - Enable or disable safe updates.
 * @param {string} feedback - Feedback regarding safe updates.
 * @param {any[]} options - Additional options for safe updates.
 * @param {boolean} checked - Whether the update status is checked or not.
 * @param {string} desc - Description of the update status.
 * @param {string} label - Label for the update status.
 * @param {number} server_id - The ID of the server.
 * @returns {Promise<{ status: boolean, data: { enabled: string } }>} A Promise that resolves with the status of the safe updates and whether they are enabled or not.
 * @example
 * {
  "status": true,
  "data": {
      "enabled": "0"
  }
}
 */
declare function UpdateSafeupdatesStatus(appType: string, app_id: number, app_name: string, enable: string, feedback: string, options: any[], checked: boolean, desc: string, label: string, server_id: number): Promise<{
    status: boolean;
    data: {
        enabled: string;
    };
}>;
/**
 * Retrieves the list of safe updates.
 * @returns {Promise<getSafeUpdatesListResponse>} A Promise that resolves with the list of safe updates.
 * @example
 * "status": true,
  "updates_list": [
    {
      "app_id": "999415377",
      "is_enable": "1",
      "update_slot": "4",
      "update_day": "4",
      "core": "no",
      "plugins": {
        "require": 0
      },
      "theme": {
        "require": 0
      }
    },
 */
declare function getSafeUpdatesList(): Promise<getSafeUpdatesListResponse>;
/**
 * Retrieves the SafeUpdates settings for a specified application.
 * @param {number} server_id - The numeric ID of the server.
 * @param {number} app_id - The numeric ID of the application.
 * @returns {Promise<SafeUpdatesSettings>} A Promise that resolves with the SafeUpdates settings.
 * @example
 * {
  "settings": {
      "id": "4760",
      "app_id": "999418464",
      "is_update_enable": "1",
      "update_list": {
          "plugin": [
              "redis-cache-pro"
          ],
          "theme": [
              "twentytwentytwo"
          ],
          "core": "no"
      },
      "available_update_list": {
          "plugin": [],
          "theme": [],
          "core": "no",
          "themes_with_versions": [],
          "plugins_with_versions": []
      },
      "update_slot": "12:01 - 18:00",
      "update_day": "Sunday",
      "updated_at": "2023-04-29 12:00:22",
      "notification_email": "fpr@cloudways.com",
      "pre_notification": "1",
      "successful_updates": "1",
      "failed_updates": "1"
  },
  "status": true
}
 */
declare function getSafeUpdatesSettings(server_id: number, app_id: number): Promise<SafeUpdatesSettings>;
/**
 * Updates the SafeUpdates settings for a specified application.
 * @param {number} app_id - The numeric ID of the application.
 * @param {string} core - The core update status ('yes' or 'no').
 * @param {string} emails - Notification email addresses.
 * @param {number} failed_updates - Number of failed updates to allow.
 * @param {any[]} plugin - List of plugin names.
 * @param {number} pre_notification - Pre-notification status (1 for enabled, 0 for disabled).
 * @param {number} server_id - The numeric ID of the server.
 * @param {number} status - Update status (1 for enabled, 0 for disabled).
 * @param {number} successful_updates - Number of successful updates to allow.
 * @param {any[]} theme - List of theme names.
 * @param {number} update_day - Update day (0 for Sunday, 1 for Monday, and so on).
 * @param {number} update_slot - Update time slot (in hours).
 * @returns {Promise<{ status: boolean }>} A Promise that resolves with the update status.
 * @example
 * {
    "status": true
}
 */
declare function postSafeUpdatesSettings(app_id: number, core: string, emails: string, failed_updates: number, plugin: any[], pre_notification: number, server_id: number, status: number, successful_updates: number, theme: any[], update_day: number, update_slot: number): Promise<{
    status: boolean;
}>;
/**
 * Retrieves the SafeUpdates schedule settings for a specific application.
 *
 * @param {number} server_id - Numeric ID of the server.
 * @param {number} app_id - Numeric ID of the application.
 * @returns {Promise<SafeUpdatesShedule>} The SafeUpdates schedule settings.
 * @example
 * {
  "status": true,
  "updates_list": {
      "core": "no",
      "themes": {
          "selected": 4,
          "updated": 4
                },
      "plugins": {
           "selected": 2,
           "updated": 2
                }
  }
}
 */
declare function getSafeUpdatesSchedule(server_id: number, app_id: number): Promise<SafeUpdatesShedule>;
/**
 * Retrieves the SafeUpdates history for a specific application.
 *
 * @param {number} server_id - Numeric ID of the server.
 * @param {number} app_id - Numeric ID of the application.
 * @returns {Promise<SafeUpdatesHistory>} The SafeUpdates history.
 * @example
 * {
  "status": true,
  "history": [
      {
          "id": "412048",
          "app_id": "999418895",
          "message": "On Demand Update Successful: ",
          "updates": {
              "core": "no",
              "themes": {
                  "selected": 2,
                  "updated": 2
              },
              "plugins": {
                  "selected": 1,
                  "updated": 1
              }
          },
          "status": "1",
          "type": "0",
          "created_at": "2023-05-02 12:29:08",
          "update_date": "2023-05-02 12:29:08",
          "reason": "Operation completed",
          "case": 1
      }]
 */
declare function getSafeUpdatesHistory(server_id: number, app_id: number): Promise<SafeUpdatesHistory>;

/**
 * Interface representing the response structure for creating DNS records.
 */
interface DnsResponse {
    wildcard_ssl: {
        message: string;
        status: boolean;
        wildcard: {
            app_prefix: string;
            auto: boolean;
            is_installed: boolean;
            is_verified: boolean;
            ssl_domains: string[];
            ssl_email: string;
            type: string;
        };
    };
}

/**
 * Allows access to Adminer on a specific server.
 * @param {number} serverId - The ID of the server where access to Adminer will be allowed.
 * @param {string} ip - The IP address that will be allowed to access Adminer on the server.
 * @returns {Promise<void>} A promise that resolves when the request to allow access to Adminer is completed.
 * @example
 * ```
 * {}
 *
 * ```
 */
declare function allowAdminer(serverId: number, ip: string): Promise<void>;
/**
 * Allows access to SIAB on a specific server.
 * @param {number} serverId - The ID of the server where access to SIAB will be allowed.
 * @param {string} ip - The IP address that will be allowed to access SIAB on the server.
 * @returns {Promise<void>} A promise that resolves when the request to allow access to SIAB is completed.
 * * @example
 * ```
 * {}
 *
 * ```
 */
declare function allowSiab(serverId: number, ip: string): Promise<void>;
/**
 * Changes the auto-renewal policy for Let's Encrypt certificates on a specific server and application.
 * @param {number} serverId - The ID of the server where the application is hosted.
 * @param {number} appId - The ID of the application for which the auto-renewal policy will be changed.
 * @param {boolean} auto - A boolean value indicating whether auto-renewal should be enabled (true) or disabled (false).
 * @returns {Promise<void>} A promise that resolves when the request to change the auto-renewal policy is completed.
 * @example
 * ```
 * {}
 *
 * ```
 */
declare function changeAutoRenewalPolicy(serverId: number, appId: number, auto: boolean): Promise<void>;
/**
 * Checks if an IP address is blacklisted on a specific server.
 * @param {number} serverId - The ID of the server to check.
 * @param {string} ip - The IP address to check.
 * @returns {Promise<boolean>} A promise that resolves to true if the IP is blacklisted, and false otherwise.
 * @example
 * {
    "ip_status" : false
    }
 */
declare function checkIfIpBlacklist(serverId: number, ip: string): Promise<boolean>;
/**
 * Gets the list of whitelisted IPs for MySQL connections on a specific server.
 * @param {number} serverId - The ID of the server to retrieve the whitelisted IPs from.
 * @returns {Promise<string[]>} A promise that resolves to an array of whitelisted IP addresses for MySQL connections.
 * @example
 * {
  "ip_list" : [ "1.1.1.1" ]
    }
 */
declare function getWhitelistedIpsMysqlConnections(serverId: number): Promise<string[]>;
/**
 * Retrieves the list of whitelisted IPs for SSH/SFTP connections on a specific server.
 * @param {number} serverId - The ID of the server to retrieve the whitelisted IPs from.
 * @returns {Promise<string[]>} A promise that resolves to an array of whitelisted IP addresses for SSH/SFTP connections.
 * @example
 * {
  "ip_list" : [ "1.1.1.1" ]
    }
 */
declare function getWhiteListedIpsForSshSftp(serverId: number): Promise<string[]>;
/**
 * Creates DNS records for a specified server and application, especially when using wildcard certificates.
 * @param {number} serverId - The ID of the server where the DNS records will be created.
 * @param {number} appId - The ID of the application for which DNS records will be created.
 * @param {string} sslEmail - The email attached to the certificate.
 * @param {boolean} wildCard - Indicates whether the certificate is a wildcard certificate.
 * @param {string} sslDomain - The domain name(s) to be protected with a single certificate.
 * @returns {Promise<DnsResponse>} A promise that resolves to the response containing information about the created DNS records.
 * @example
 * ```
 * {
  "wildcard_ssl": {
        "message":"Succefully DNS created",
        "status":true,
        "wildcard": {
            "app_prefix":"woocommerce-111-160.cloudwaysapps.com",
            "auto":true,
            "is_installed":false,
            "is_verified":false,
            "ssl_domains":["xyz.com"],
            "ssl_email":"example@gmail.com",
            "type":"wc"
        }
  }
}
 * ```
 */
declare function createDns(serverId: number, appId: number, sslEmail: string, wildCard: boolean, sslDomain: string): Promise<DnsResponse>;
/**
 * Verifies DNS records for a specified server and application, especially when using wildcard certificates.
 * @param {number} serverId - The ID of the server where the DNS records will be verified.
 * @param {number} appId - The ID of the application for which DNS records will be verified.
 * @param {string} sslEmail - The email attached to the certificate.
 * @param {boolean} wildCard - Indicates whether the certificate is a wildcard certificate.
 * @param {string} sslDomain - The domain name(s) to be protected with a single certificate.
 * @returns {Promise<DnsResponse>} A promise that resolves to the response containing information about the verified DNS records.
 * @example
 * ```
 * {
  "wildcard_ssl": {
        "message":"Your domain is mapped, kindly proceed",
        "status":true,
        "wildcard": {
            "app_prefix":"woocommerce-111-160.cloudwaysapps.com",
            "auto":true,
            "is_installed":false,
            "is_verified":false,
            "ssl_domains":["xyz.com"],
            "ssl_email":"example@gmail.com",
            "type":"wc"
        }
  }
}
 * ```
 */
declare function verifyDns(serverId: number, appId: number, sslEmail: string, wildCard: boolean, sslDomain: string): Promise<DnsResponse>;
/**
 * Installs Let's Encrypt SSL certificates for a specified server and application.
 * @param {number} serverId - The ID of the server where Let's Encrypt SSL will be installed.
 * @param {number} appId - The ID of the application for which Let's Encrypt SSL will be installed.
 * @param {string} sslEmail - The email attached to the Let's Encrypt SSL certificate.
 * @param {boolean} wildCard - Indicates whether the Let's Encrypt SSL certificate is a wildcard certificate.
 * @param {string[]} sslDomains - An array of domain names to be protected with Let's Encrypt SSL.
 * @returns {Promise<OperationStatus>} A promise that resolves to the ID of the operation.
 * @example
 * ```{
  "operation_id" : 12345
    }```
 */
declare function installLetsEncrypt(serverId: number, appId: number, sslEmail: string, wildCard: boolean, sslDomains: string[]): Promise<OperationStatus>;
/**
 * Manually renews Let's Encrypt SSL certificates for a specified server and application.
 * @param {number} serverId - The ID of the server where Let's Encrypt SSL will be renewed.
 * @param {number} appId - The ID of the application for which Let's Encrypt SSL will be renewed.
 * @param {boolean} wildCard - Indicates whether the Let's Encrypt SSL certificate is a wildcard certificate.
 * @param {string} domain - The domain name for which Let's Encrypt SSL will be renewed.
 * @returns {Promise<OperationStatus>} A promise that resolves to the ID of the operation.
 * @example
 * ```{
  "operation_id" : 12345
    }```
 */
declare function renewLetsEncryptManually(serverId: number, appId: number, wildCard: boolean, domain: string): Promise<OperationStatus>;
/**
 * Revokes Let's Encrypt SSL certificates for a specified server and application.
 * @param {number} serverId - The ID of the server from which Let's Encrypt SSL will be revoked.
 * @param {number} appId - The ID of the application for which Let's Encrypt SSL will be revoked.
 * @param {boolean} wildCard - Indicates whether the Let's Encrypt SSL certificate is a wildcard certificate.
 * @param {string} ssl_domain - The domain name for which Let's Encrypt SSL will be revoked.
 * @returns {Promise<OperationStatus>} A promise that resolves to the ID of the operation.
 * @example
 * ```{
  "operation_id" : 12345
    }```
 */
declare function revokeLetsEncrypt(serverId: number, appId: number, wildCard: boolean, ssl_domain: string): Promise<OperationStatus>;
/**
 * SSL certificate and key for a specified server and application.
 * @param {number} serverId - The ID of the server where the SSL certificate will be installed.
 * @param {number} appId - The ID of the application for which the SSL certificate will be installed.
 * @param {string} sslCertificate - The custom SSL certificate to be installed.
 * @param {string} sslKey - The corresponding SSL key for the custom certificate.
 * @returns {Promise<void>} A promise that resolves when the installation process is completed successfully.
 * @example
 *  {}
 */
declare function ownSslCertificate(serverId: number, appId: number, sslCertificate: string, sslKey: string): Promise<void>;
/**
 * Removes a custom SSL certificate for a specified server and application.
 * @param {number} serverId - The ID of the server from which the custom SSL certificate will be removed.
 * @param {number} appId - The ID of the application for which the custom SSL certificate will be removed.
 * @returns {Promise<OperationStatus>} A promise that resolves to the ID of the operation.
 * @example
 * ```
 * {
 * "operation_id": 12345
 * }
 * ```
 */
declare function removeOwnSslCertificate(serverId: number, appId: number): Promise<OperationStatus>;
declare function updateWhitelistedIps(serverId: number, ipPolicy: string, //"allow_all" or "block_all(only for sftp)"
tab: string, //"sftp " or "mysql"
Ips: string[], type_connection: string): Promise<void>;

/**
 * interface to get server settings response
 
 */
interface getServerSettingsResponse {
    settings: {
        character_set_server: string;
        timezone: string;
        direct_access: string;
        display_errors: string;
        error_reporting: string;
        execution_limit: string;
        innodb_buffer_pool_size: string;
        innodb_lock_wait_timeout: string;
        max_connections: string;
        max_input_time: string;
        max_input_vars: string;
        memory_limit: string;
        mod_xdebug: string;
        package_versions: {
            fpm: string;
            mariadb: string;
            mysql: string;
            php: string;
            redis: string;
        };
        short_open_tag: string;
        ssl_protocols: string;
        static_cache_expiry: string;
        upload_size: string;
        varnish_default_ttl: string;
        wait_timeout: string;
    };
}
/**
 * interface to get disk cleanup settings response
 */
interface getDiskCleanupResponse {
    settings: {
        automate_cleanup: string;
        remove_app_local_backup: string;
        remove_app_private_html: string;
        remove_app_tmp: string;
        rotate_app_log: string;
        rotate_system_log: string;
    };
}

/**
 * Initiates a backup for the specified server.
 * @param {number} serverId - The numeric ID of the server.
 * @returns {Promise<OperationStatus> } A Promise that resolves to an object containing the operation ID.
 * @example
 * {
  "operation_id" : 12345
}
 */
declare function backupServer(serverId: number): Promise<OperationStatus>;
/**
 * Deletes local backups for the specified server.
 * @param {number} serverId - The numeric ID of the server.
 * @returns {Promise<void>} A Promise that resolves once the local backups are deleted.
 */
declare function deleteLocalServerBackups(serverId: number): Promise<void>;
/**
 * Retrieves monitoring graph data for the specified server.
 * @param {number} serverId - The numeric ID of the server.
 * @param {string} target - The target for the monitoring graph.
 * @param {string} duration - The duration for which the data should be retrieved.
 * @param {string} timezone - The timezone for the data.
 * @param {string} output_format - The output format for the data.
 * @returns {Promise<{ contents: string }>} A Promise that resolves with the monitoring graph contents.
 * @example
 * {
  "contents" : ""
}
 */
declare function getMonitoringGraph(serverId: number, target: string, duration: string, timezone: string, output_format: string): Promise<{
    contents: string;
}>;
/**
 * Retrieves server settings and installed package versions.
 * @param {number} serverId - Numeric id of the server.
 * @returns {Promise<getServerSettingsResponse>} - Promise containing server settings response.
 * @example
 * {
  "settings" : {
    "character_set_server" : "ascii",
    "date.timezone" : "",
    "direct_access": "enable",
    "display_errors" : "Off",
    "error_reporting" : "E_ALL & ~E_DEPRECATED & ~E_STRICT",
    "execution_limit" : "60",
    "innodb_buffer_pool_size" : "",
    "innodb_lock_wait_timeout" : "",
    "max_connections" : "150",
    "max_input_time" : "60",
    "max_input_vars" : "2500",
    "memory_limit" : "128",
    "mod_xdebug": "disable",
    "package_versions" : {
      "fpm":"enable",
      "mariadb" : "",
      "mysql" : "5.5",
      "php" : "5.6",
      "redis" : ""
    },
    "short_open_tag": "Off",
    "ssl_protocols":"1.0,1.1,1.2,1.3",
    "static_cache_expiry" : "43200",
    "upload_size" : "10",
    "varnish_default_ttl": "4h",
    "wait_timeout" : ""
  }
}
 */
declare function getServerSettings(serverId: number): Promise<getServerSettingsResponse>;
/**
 * Retrieves maintenance window settings for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @returns {Promise<{ maintenance_settings: { day: string, hour: number } }>} - Promise containing maintenance window settings.
 * @example
 * {
  "maintenance_settings": {
                      "day": 'Monday',
                      "hour": 2
                    }
}
 */
declare function getServerMaintenanceWindowSettings(serverId: number): Promise<{
    maintenance_settings: {
        day: string;
        hour: number;
    };
}>;
/**
 * Updates maintenance window settings for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} day - Maintenance day.
 * @param {number} hour - Maintenance hour.
 * @returns {Promise<{ message: string }>} - Promise containing a message indicating the success of the operation.
 * @exmaple
 * {
    "message": 'Maintenance Time Successfully Update',
 }
 */
declare function updateServerMaintenanceWindowSettings(serverId: number, day: string, hour: number): Promise<{
    message: string;
}>;
/**
 * Updates backup settings for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {boolean} local_backups - Indicates whether local backups are enabled.
 * @param {string} backup_frequency - Frequency of backups.
 * @param {string} backup_retention - Retention policy for backups.
 * @param {string} backup_time - Time for backup execution.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateBackupSettings(serverId: number, local_backups: boolean, backup_frequency: string, backup_retention: string, backup_time: string): Promise<void>;
/**
 * Updates the master password for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} password - New master password for the server.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateMasterPassword(serverId: number, password: string): Promise<void>;
/**
 * Updates the master username for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} username - New master username for the server.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateMasterUsername(serverId: number, username: string): Promise<void>;
/**
 * Updates the package version for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} package_name - Name of the package to be updated.
 * @param {string} package_version - New version of the package.
 * @returns {Promise<OperationStatus>} - Promise containing the operation id.
 * @example
 * {
  "operation_id" : 12345
}
 */
declare function updateServerPackage(serverId: number, package_name: string, package_version: string): Promise<OperationStatus>;
declare function updateServerSettings(serverId: number, execution_limit: number, memory_limit: number, date_timezone: string, display_errors: string, upload_size: number, error_reporting: string, mysql_timezone: string, static_cache_expiry: number, character_set_server: string, max_connections: number, max_input_vars: number, max_input_time: number, tls_version: string, mod_zendguard: string, innodb_buffer_pool_size: number, innodb_lock_wait_timeout: number, wait_timeout: number, opcache_memory_size: number, mod_xdebug: string, nginx_http2: string, new_default_app: string, sys_locale: string, varnish_default_ttl: string): Promise<void>;
/**
 * Updates the snapshot frequency for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} snapshot_frecuency - New snapshot frequency value.
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateSnapshotFrecuency(serverId: number, snapshot_frecuency: number): Promise<void>;
/**
 * Retrieves the disk cleanup settings for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @returns {Promise<getDiskCleanupResponse>} - Promise resolving to the disk cleanup settings response.
 * @example
 * {
  "settings": {
    "automate_cleanup": "disabled",
    "remove_app_local_backup": "no",
    "remove_app_private_html": "no",
    "remove_app_tmp": "no",
    "rotate_app_log": "no",
    "rotate_system_log": "no"
  }
}
 */
declare function getDiskCleanupSettings(serverId: number): Promise<getDiskCleanupResponse>;
/**
 * Updates the disk cleanup settings for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} automate_cleanup - Setting to automate cleanup.
 * @param {string} remove_app_tmp - Setting to remove temporary app files.
 * @param {string} remove_app_private_html - Setting to remove private HTML files.
 * @param {string} rotate_system_log - Setting to rotate system logs.
 * @param {string} rotate_app_log - Setting to rotate app logs.
 * @param {string} remove_app_local_backup - Setting to remove local app backups.
 * @returns {Promise<void>} - Promise resolving when the settings are successfully updated.
 */
declare function updateDiskCleanupSettings(serverId: number, automate_cleanup: string, remove_app_tmp: string, remove_app_private_html: string, rotate_system_log: string, rotate_app_log: string, remove_app_local_backup: string): Promise<void>;
/**
 * Optimizes the disk of the specified server by performing cleanup actions.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} remove_app_tmp - Setting to remove temporary app files.
 * @param {string} remove_app_private_html - Setting to remove private HTML files.
 * @param {string} rotate_system_log - Setting to rotate system logs.
 * @param {string} rotate_app_log - Setting to rotate app logs.
 * @param {string} remove_app_local_backup - Setting to remove local app backups.
 * @returns {Promise<OperationStatus>} - Promise resolving with status and operation id.
 * @example
 * {
  "status": true,
  "operation_id": 3
}
 */
declare function optimizeServerDisk(serverId: number, remove_app_tmp: string, remove_app_private_html: string, rotate_system_log: string, rotate_app_log: string, remove_app_local_backup: string): Promise<OperationStatus>;

/**
 * Interface to get service status
 */
interface getServiceStatusResponse {
    services: {
        status: {
            apache2: string;
            elasticsearch: string;
            elasticsearch_enabled: number;
            memcached: string;
            mysql: string;
            "newrelic-sysmond": string;
            nginx: string;
            "redis-server": string;
            redis_enabled: number;
            varnish: string;
            varnish_enabled: number;
        };
    };
}

/**
 * Changes the state of a service on the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} service - Name of the service.
 * @param {string} state - Desired state of the service.
 * @returns {Promise<{ service_status: { status: string } }>} - Promise resolving with the status of the service.
 * @example
 * {
  "service_status" : {
    "status" : "running"
  }
}
 */
declare function changeServiceState(serverId: number, service: string, state: string): Promise<{
    service_status: {
        status: string;
    };
}>;
/**
 * Retrieves the status of services on the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @returns {Promise<getServiceStatusResponse>} - Promise resolving with the status of services.
 * @example
 *
 */
declare function getServiceStatus(serverId: number): Promise<getServiceStatusResponse>;
/**
 * Retrieves the Varnish state at the application level for the specified server and application.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} appId - Numeric id of the application.
 * @returns {Promise<void>} - Promise resolving with the Varnish state.
 */
declare function getVarnishStateAppLevel(serverId: number, appId: number): Promise<void>;
/**
 * Updates the Varnish state for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} action - Action to perform on Varnish (e.g., "start", "stop").
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateServerVarnishState(serverId: number, action: string): Promise<void>;
/**
 * Updates the Varnish state at the application level for the specified server.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} appId - Numeric id of the application.
 * @param {string} action - Action to perform on Varnish (e.g., "start", "stop").
 * @returns {Promise<void>} - Promise indicating the success of the operation.
 */
declare function updateVarnishStateAppLevel(serverId: number, appId: number, action: string): Promise<void>;

/**
 * Retrieves application table information.
 *
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<void>} - A Promise that resolves when the request is complete.
 */
declare function getAplicationTable(serverId: number, appId: number): Promise<void>;
/**
 * Synchronize application between servers.
 *
 * @param {number} serverId - Numeric ID of the destination server.
 * @param {number} appId - Numeric ID of the destination application.
 * @param {number} sourceAppId - Numeric ID of the source application.
 * @param {number} sourceServerId - Numeric ID of the source server.
 * @param {string} action - Action to perform. Possible values are "Push" or "Pull".
 * @param {boolean} [appFiles=false] - Whether to include application files in the synchronization.
 * @param {string} [appFilesType] - Type of application files to deploy.
 * @param {string[]} [excludePath] - List of files or folders paths to exclude during synchronization.
 * @param {boolean} [dbFiles=false] - Whether to include database files in the synchronization.
 * @param {boolean} [backup=false] - Whether to backup application files before synchronization.
 * @param {boolean} [table=false] - Whether to backup tables before synchronization.
 * @param {string[]} [tableSelected] - List of tables to backup.
 * @returns {Promise<void>} - A Promise that resolves when the synchronization is complete.
 */
declare function syncApp(serverId: number, appId: number, sourceAppId: number, sourceServerId: number, action: string, appFiles?: boolean, appFilesType?: string, excludePath?: string[], dbFiles?: boolean, backup?: boolean, table?: boolean, tableSelected?: string[]): Promise<void>;
/**

Sends a request to update the status of the .htaccess authentication credentials.
@param {number} serverId - The numeric ID of the server.
@param {number} appId - The numeric ID of the application.
@param {string} action - The action to perform. Possible values are 'enable' or 'disable'.
@returns {Promise<void>} - A Promise that resolves when the request is complete.
*/
declare function HtaccessAuthCredentials(serverId: number, appId: number, action: string): Promise<void>;
/**
 * Updates the `.htaccess` authentication credentials.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @param {string} username - The new username for authentication.
 * @param {string} password - The new password for authentication.
 * @returns {Promise<void>} - A Promise that resolves when the request is complete.
 */
declare function HtaccesUpdateCredentials(serverId: number, appId: number, username: string, password: string): Promise<void>;
/**
 * Retrieves deployment logs for a staging application.
 * @param {number} serverId - The numeric ID of the server.
 * @param {number} appId - The numeric ID of the application.
 * @returns {Promise<void>} - A Promise that resolves when the logs are retrieved.
 */
declare function stagingApplicationDeploymentLogs(serverId: number, appId: number): Promise<void>;

/**
 * Insterface to create a Supervisord queue
 */
interface createSupervisordResponse {
    queues_list: {
        id: string;
        timeout: string;
        sleep: string;
        queue: string;
        tries: string;
        env: string;
        connection: string;
        procs: string;
        queue_id: string;
        artisan_path: string;
    }[];
    status: boolean;
}
/**
 * Interface to delete supervisord queue
 */
interface deleteSupervisordQueues {
    queues_list: {
        id: string;
        timeout: string;
        sleep: string;
        queue: string;
        tries: string;
        env: string;
        connection: string;
        procs: string;
        queue_id: string;
        artisan_path: string;
    }[];
    status: boolean;
}
/**
 * Interface to get status of supervisord queue
 */
interface getSupervisordQueueStatus {
    response: {
        details: string;
        queue_id: string;
        state: string;
    }[];
    status: boolean;
}
/**
 * Interface to get supervisord queuea
 */
interface getSupervisordQueuesResponse {
    status: boolean;
    is_enabled: boolean;
    queues_list: {
        id: string;
        timeout: string;
        sleep: string;
        queue: string;
        tries: string;
        env: string;
        connection: string;
        procs: string;
        queue_id: string;
        artisan_path: string;
    }[];
}

/**
 * Creates a new supervisord queue for the specified application on the server.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} appId - Numeric id of the application.
 * @param {string} queues_list_connection - The connection type for the queue.
 * @param {number} queues_list_procs - The number of processes for the queue.
 * @param {number} queues_list_sleep - The time to sleep between processes.
 * @param {string} queues_list_artisan_path - The artisan path for the queue.
 * @param {number} queues_list_timeout - The timeout for the queue.
 * @param {string} queues_list_queue - The queue name.
 * @param {number} queues_list_tries - The number of tries for the queue.
 * @param {string} queues_list_env - The environment for the queue.
 * @returns {Promise<createSupervisordResponse>} - Promise resolving with the response from the API.
 * @example
 * {
  "queues_list" : [ {
    "id" : "19",
    "timeout" : "60",
    "sleep" : "3",
    "queue" : "default",
    "tries" : "0",
    "env" : "",
    "connection" : "redis",
    "procs" : "1",
    "queue_id" : "abcdefghij_1",
    "artisan_path" : "public_html/artisan"
  } ],
  "status" : true
}
 */
declare function createSupervisordQueue(serverId: number, appId: number, queues_list_connection: string, queues_list_procs: number, queues_list_sleep: number, queues_list_artisan_path: string, queues_list_timeout: number, queues_list_queue: string, queues_list_tries: number, queues_list_env: string): Promise<createSupervisordResponse>;
/**
 * Deletes a supervisord queue for the specified application on the server.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} appId - Numeric id of the application.
 * @param {number} id - Numeric id of the supervisord queue.
 * @returns {Promise<deleteSupervisordQueues>} - Promise resolving with the response from the API.
 * @example
 * {
  "queues_list" : [ {
    "id" : "11",
    "timeout" : "60",
    "sleep" : "3",
    "queue" : "default",
    "tries" : "0",
    "env" : "dev",
    "connection" : "redis",
    "procs" : "1",
    "queue_id" : "abcdefghij_2",
    "artisan_path" : "public_html/artisan"
  } ],
  "status" : true
}
 */
declare function deleteSupervisordQueue(serverId: number, appId: number, id: number): Promise<deleteSupervisordQueues>;
/**
 * Retrieves the status of supervisord queues for the specified application on the server.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} appId - Numeric id of the application.
 * @returns {Promise<getSupervisordQueueStatus>} - Promise resolving with the status of supervisord queues.
 * @example
 * {
  "response" : [ {
    "details" : "pid 2679, uptime 3:31:07",
    "queue_id" : "xpsahsdas_003_00",
    "state" : "RUNNING"
  } ],
  "status" : true
}
 */
declare function getupervisordQueueStatus(serverId: number, appId: number): Promise<getSupervisordQueueStatus>;
/**
 * Retrieves the list of supervisord queues for the specified application on the server.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} appId - Numeric id of the application.
 * @returns {Promise<getSupervisordQueuesResponse>} - Promise resolving with the list of supervisord queues.
 * @example
 * {
  "status" : true,
  "is_enabled" : true,
  "queues_list" : [ {
    "id" : "19",
    "timeout" : "60",
    "sleep" : "3",
    "queue" : "default",
    "tries" : "0",
    "env" : "",
    "connection" : "redis",
    "procs" : "1",
    "queue_id" : "abcdefghij_1",
    "artisan_path" : "public_html/artisan"
  } ]
}
 */
declare function getupervisordQueues(serverId: number, appId: number): Promise<getSupervisordQueuesResponse>;
/**
 * Restarts a supervisord queue for the specified application on the server.
 * @param {number} serverId - Numeric id of the server.
 * @param {number} appId - Numeric id of the application.
 * @param {number} queueId - Numeric id of the supervisord queue.
 * @returns {Promise<{ response: string; status: boolean }>} - Promise resolving with the restart response and status.
 * @example
 * {
  "response" : "",
  "status" : true
}
 */
declare function restartSupervisordQueue(serverId: number, appId: number, queueId: number): Promise<{
    response: string;
    status: boolean;
}>;

interface getAllTeamMemberResponse {
    contents: {
        members: {
            [key: string]: {
                id: string;
                member_mapping_id: string;
                name: string;
                email: string;
                status: string;
                image: string;
                added_on: string;
                role: string;
                account_disabled: string;
                acc_cancellation_date: null | string;
                permissions: {
                    is_full: boolean;
                };
            };
        };
    };
}

/**
 * Retrieves all team members.
 * @returns {Promise<getAllTeamMemberResponse>} - Promise resolving with the response containing all team members.
 * @example
 * {
            "contents": {
              "members": {
                "26740": {
                  "id": "26740",
                  "member_mapping_id": "19",
                  "name": "Team Member",
                  "email": "teamMember@gmail.com",
                  "status": "1",
                  "image": "https://s3.amazonaws.com/cng-console-content/user_pics/5d0ce92114630.png",
                  "added_on": "2019-06-21 16:26:40",
                  "role": "Project Manager",
                  "account_disabled": "0",
                  "acc_cancellation_date": null,
                  "permissions": {
                    "is_full": true
                  }
                }
              }
            }
          }
 */
declare function getAllTeamMember(): Promise<getAllTeamMemberResponse>;
/**
 * Adds a new team member with the specified details.
 * @param {Object} memberDetails - Details of the new team member.
 * @param {string} memberDetails.name - Name of the new member.
 * @param {string} memberDetails.email - Email of the new member.
 * @param {number} memberDetails.status - Status of the new member (1 for active, 0 for inactive).
 * @param {string} memberDetails.role - Role of the new member.
 * @param {Object} memberDetails.account - Account access details.
 * @param {string[]} memberDetails.account.sections - Sections of the account that the new member has access to.
 * @param {boolean} memberDetails.account.is_full - Indicates whether the new member has full account access.
 * @param {Object} memberDetails.servers - Server access details.
 * @param {Object} memberDetails.servers.<serverId> - Access details for a specific server.
 * @param {string[]} memberDetails.servers.<serverId>.sections - Sections of the server that the new member has access to.
 * @param {boolean} memberDetails.servers.<serverId>.is_full - Indicates whether the new member has full server access.
 * @param {string[]} memberDetails.apps - IDs of the applications that the new member has access to.
 * @returns {Promise<getAllTeamMemberResponse>} - Promise resolving with the server response.
 * @example
 *  {
                  "contents": {
                    "members": {
                      "26740": {
                        "id": "26740",
                        "member_mapping_id": "19",
                        "name": "Team Member",
                        "email": "teamMember@gmail.com",
                        "status": "1",
                        "image": "https://s3.amazonaws.com/cng-console-content/user_pics/5d0ce92114630.png",
                        "added_on": "2019-06-21 16:26:40",
                        "role": "Project Manager",
                        "account_disabled": "0",
                        "acc_cancellation_date": null,
                        "permissions": {
                          "is_full": true
                        }
                      }
                    }
                  }
                }
 */
declare function addTeamMember(memberDetails: any): Promise<getAllTeamMemberResponse>;
/**
 * Updates the details of a specific team member.
 * @param {number} memberId - The ID of the member to update.
 * @param {Object} memberDetails - Updated details of the team member.
 * @param {string} memberDetails.name - Updated name of the member.
 * @param {string} memberDetails.email - Updated email of the member.
 * @param {number} memberDetails.status - Updated status of the member (1 for active, 0 for inactive).
 * @param {string} memberDetails.role - Updated role of the member.
 * @param {Object} memberDetails.account - Updated account access details.
 * @param {string[]} memberDetails.account.sections - Updated sections of the account that the member has access to.
 * @param {boolean} memberDetails.account.is_full - Indicates whether the member has full account access.
 * @param {Object} memberDetails.servers - Updated server access details.
 * @param {Object} memberDetails.servers.<serverId> - Updated access details for a specific server.
 * @param {string[]} memberDetails.servers.<serverId>.sections - Updated sections of the server that the member has access to.
 * @param {boolean} memberDetails.servers.<serverId>.is_full - Indicates whether the member has full server access.
 * @param {string[]} memberDetails.apps - Updated IDs of the applications that the member has access to.
 * @returns {Promise<getAllTeamMemberResponse>} - Promise resolving with the server response.
 * @example
 * {
          {
            "contents": {
              "members": {
                "26740": {
                  "id": "26740",
                  "member_mapping_id": "19",
                  "name": "Team Member",
                  "email": "teamMember@gmail.com",
                  "status": "1",
                  "image": "https://s3.amazonaws.com/cng-console-content/user_pics/5d0ce92114630.png",
                  "added_on": "2019-06-21 16:26:40",
                  "role": "Project Manager",
                  "account_disabled": "0",
                  "acc_cancellation_date": null,
                  "permissions": {
                    "is_full": true
                  }
                }
              }
            }
          }
  
}
 */
declare function updateTeamMember(memberId: number, memberDetails: any): Promise<getAllTeamMemberResponse>;
/**
* Deletes a team member from the specified member ID.
* @param {number} memberId - The ID of the member to delete.
* @param {number} id - The ID of the member to delete (redundant, can be removed).
* @returns {Promise<void>} - Promise resolving once the member is deleted.
*/
declare function deleteTeamMember(memberId: number, id: number): Promise<void>;

/**
 * Interface to get server transfer status
 */
interface getServerTransferResponse {
    share: null | any;
    transfer: {
        id: string;
        name: string;
        email: string;
    };
}

/**
 * Cancels the ongoing server transfer process.
 * @param {number} serverId - Numeric id of the server.
 * @returns {Promise<{ status : boolean}>} - Promise resolving with the cancellation status.
 * @example
 * {
  "status" : true
}
 */
declare function cancelServerTransferProcess(serverId: number): Promise<{
    status: boolean;
}>;
/**
 * Retrieves the status of the server transfer process.
 * @param {number} serverId - Numeric id of the server.
 * @returns {Promise<getServerTransferResponse>} - Promise resolving with the server transfer status.
 * @example
 * {
  "share" : null,
  "transfer" : {
    "id" : "123",
    "name" : "Cloudways user",
    "email" : "user@cloudways.com"
  }
}
 */
declare function getServerTransferStatus(serverId: number): Promise<getServerTransferResponse>;
/**
 * Initiates a request for server transfer.
 * @param {number} serverId - Numeric id of the server.
 * @param {string} email - Email address to request server transfer.
 * @returns {Promise<{ status : boolean}>} - Promise resolving with the status of the server transfer request.
 * @example
 * {
  "status" : true
}
 */
declare function requestForServerTransfer(serverId: number, email: string): Promise<{
    status: boolean;
}>;

export { type ActivateAddonAccountLevelResponse, AddDNSMadeEasyDomains, AddRecordToDnsMadeEasyDomain, type AddonsListResponse, type AlertChannel, type AlertEvent, type App, type AppBackupStatusResponse, type AppCredentialsResponse, type AppInfo, type AppVersion, type ApplicationAccessStateResponse, type AuthToken, type BackupFrequency, BotProtectionActivation, BotProtectionBadBotsList, type BotProtectionBadBotsListResponse, BotProtectionBadBotsWhitelisting, BotProtectionDeactivation, BotProtectionIpWhitelisting, BotProtectionLoginTraffic, type BotProtectionLoginTrafficResponse, BotProtectionLoginTrafficSummary, type BotProtectionLoginTrafficSummaryResponse, BotProtectionStatus, BotProtectionTraffic, type BotProtectionTrafficResponse, BotProtectionTrafficSummary, type BotProtectionTrafficSummaryResponse, BotProtectionWhiteListedBots, BotProtectionWhiteListedIps, type CacheStatus, type ChannelConfig, ClearAppCache, type Country, type CreateAlertChannelResponse, type CreateProjectResponse, type CronListResponse, type DNSMadeEasyDomain, type DNSRecord, type DeactivateAnAddonResponse, DeleteApp, DeleteDNSMadeEasyDomains, DeleteRecordfromDnsMadeEasyDomain, type DiskUsageResponse, type DnsResponse, type ElasticEmailDomainsResponse, type FetchTxtRecordsResponse, type FpmSettingsResponse, type GetAllAlertChannelsResponse, type GetAllAlertsResponse, type GetAppListResponse, type GetCloudflareCacheAnalyticsResponse, type GetCloudflareSecurityAnalyticsResponse, GetCurrentMonthDnsMadeEasyDomainUsage, type GetDNSMadeEasyDomainRecordsResponse, type GetMonitorDurationsResponse, type GetMonitorTargetsResponse, type GetOAuthAccessTokenRequest, type GetOAuthAccessTokenResponse, type GetProjectListResponse, type GetProviderListResponse, type GetRegionListResponse, type GetServerSizesListResponse, type GetSettingsListResponse, HtaccesUpdateCredentials, HtaccessAuthCredentials, HttpMethod, type ListApplicationVulnerabilitiesResponse, type ListDNSMadeEasyDomainsResponse, type Metric, type MetricWithAvg, type MetricWithoutAvg, type PackageList, type Project, type Provider, type Region, type SSHAccessStatusResponse, type SafeUpdate, type SafeUpdatesHistory, type SafeUpdatesSettings, type SafeUpdatesShedule, type SecurityAnalyticsData, type ServedBy, type Server, type ServerMonitoringTarget, type ServerSize, type Setting, type SettingsOptions, type UpdateAppXMLRPCHeaderResponse, type UpdateGeoIpHeaderResponse, type UpdateIntegrationResponse, type UpdateProjectResponse, UpdateSafeupdates, UpdateSafeupdatesStatus, type UpgradeAddonResponse, type UserAlertChannel, type VarnishSettingsResponse, activateAddOnServer, activateAddonOnAccountLevel, addApp, type addRecordToDnsMadeEasyDomainResponse, addTeamMember, addonRequestForApplication, allowAdminer, allowSiab, apiCall, aplicationBackup, attachBlockStorage, backupServer, cancelServerTransferProcess, changeAppAccessState, changeAutoRenewalPolicy, changeServiceState, checkIfIpBlacklist, cloneApp, cloneAppToOtherServer, cloneServer, cloneStagingApp, cloneStagingAppToOtherServer, type cloudflareDetailsResponse, configureSmartCachePurge, createAlertChannel, createAppCredentials, createDns, createProject, createSSHKey, createServer, createSupervisordQueue, type createSupervisordResponse, deactivateAddOnYourServer, deactivateAnAddon, deleteAppCredential, deleteCloudwaysBotChannel, deleteCname, deleteDomain, deleteElasticEmailDomain, deleteLocalBackup, deleteLocalServerBackups, deleteProject, deleteSSHKey, deleteServer, deleteSupervisordQueue, type deleteSupervisordQueues, deleteTeamMember, enforceHTTPS, fetchTxtRecords, generateGitSsh, getAddonsList, getAllAlertChannels, getAllAlerts, getAllTeamMember, type getAllTeamMemberResponse, getAndWaitForOperationStatusCompleted, getAplicacionWebPRedirectionStatus, getAplicationTable, getAppBackupStatus, getAppCredentials, getAppList, type getAppSettingResponse, getAppSettingValue, getApplicationAccessState, getApplicationCron, getApplicationDiskUsage, getApplicationDiskUsageGraph, getApplicationSshAccessStatus, getApplicationTrafficAnalytics, getApplicationTrafficDetail, getBackupFrequencies, getBranchNames, getCloudflareDetails, getClouflareCacheAnalytics, getClouflareSecurityAnalytics, getClouflareSettings, getCountriesList, getCronList, type getCurrentMonthDnsUsageResponse, getDNSMadeEasyDomainsRecords, getDNSMadeEasyDomainsStatus, type getDiskCleanupResponse, getDiskCleanupSettings, getDiskUsage, getDnsQuery, getElasticEmailDomains, getFpmSettings, getGitDeploymentHistory, getGitSsh, getMonitorDurations, getMonitorTargets, getMonitoringGraph, getMySQLInformation, getOperationStatus, getPHPInformation, getPackageList, getPaginatedAlerts, getProjectList, getProviderList, getRegionList, getSafeUpdatesDetail, getSafeUpdatesHistory, getSafeUpdatesList, type getSafeUpdatesListResponse, getSafeUpdatesSchedule, getSafeUpdatesSettings, getSafeUpdatesStatus, getServerMaintenanceWindowSettings, getServerSettings, type getServerSettingsResponse, getServerSizesList, getServerSummary, getServerTransferStatus, getServerUsage, getServersList, getServiceStatus, type getServiceStatusResponse, getSettingsList, type getSmartCachePurgeResponse, getSmartCachePurgeStatus, type getSupervisordQueueStatus, type getSupervisordQueuesResponse, getUserAlertChannels, getVarnishSettings, getVarnishStateAppLevel, getWhiteListedIpsForSshSftp, getWhitelistedIpsMysqlConnections, type getcloudflareSettingsResponse, getupervisordQueueStatus, getupervisordQueues, type gitDeploymentHistoryResponse, initializeCloudwaysApi, installLetsEncrypt, listApplicationVulnerabilities, listDNSMadeEasyDomains, markAlertAsRead, markAllAlertsAsRead, optimizeServerDisk, ownSslCertificate, postSafeUpdatesSettings, purgeDomain, refreshApplicationVulnerabilities, removeOwnSslCertificate, renewLetsEncryptManually, requestForServerTransfer, resetFilePermissions, restartServer, restartSupervisordQueue, restoreApp, revokeLetsEncrypt, rollbackRestore, scaleBlockStorage, scaleVolumeSize, searchKnowledgeBase, setUpCloudflareforYourApp, type setupCloudflareResponse, stagingApplicationDeploymentLogs, startGitClone, startGitPull, startServer, stopServer, syncApp, transferDomain, updateAppAdminPassword, updateAppAlias, updateAppCname, updateAppCredential, updateAppGeoIpHeaderStatus, updateAppLabel, updateAppXMLRCPheaderStatus, updateApplicationSshAccessStatus, updateBackupSettings, updateCloudflareSettings, updateCloudwaysBotIntegration, updateCorsHeaders, updateCronList, updateCronOptimizerStatus, updateDBPassword, updateDeviceDetentionStatus, updateDirectPHPExecutionStatus, updateDiskCleanupSettings, updateFPMsettings, updateIgnoreQueryStringStatus, updateMasterPassword, updateMasterUsername, updateProject, updateRecordOfDnsMadeEasyDomain, updateSSHKey, updateServerLabel, updateServerMaintenanceWindowSettings, updateServerPackage, updateServerSettings, updateServerVarnishState, updateSnapshotFrecuency, updateSymlink, updateTeamMember, updateVarnishSettings, updateVarnishStateAppLevel, updateWebroot, updateWhitelistedIps, upgradeAddonPackage, upgradeServer, verifyDns, verifyElasticEmailDomain, type verifyEmailDomainResponse, verifyTxtRecords };