@appconda/nextjs 1.0.114 → 1.0.116

package/dist/services/health.js

@@ -0,0 +1,463 @@
+import { AppcondaException } from '../client';
+export class Health {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get HTTP
+     *
+     * Check the Appconda HTTP server is up and responsive.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthStatus>}
+     */
+    async get() {
+        const apiPath = '/health';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get antivirus
+     *
+     * Check the Appconda Antivirus server is up and connection is successful.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthAntivirus>}
+     */
+    async getAntivirus() {
+        const apiPath = '/health/anti-virus';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get cache
+     *
+     * Check the Appconda in-memory cache servers are up and connection is successful.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthStatus>}
+     */
+    async getCache() {
+        const apiPath = '/health/cache';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get the SSL certificate for a domain
+     *
+     * Get the SSL certificate for a domain
+     *
+     * @param {string} domain
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthCertificate>}
+     */
+    async getCertificate(domain) {
+        const apiPath = '/health/certificate';
+        const payload = {};
+        if (typeof domain !== 'undefined') {
+            payload['domain'] = domain;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get DB
+     *
+     * Check the Appconda database servers are up and connection is successful.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthStatus>}
+     */
+    async getDB() {
+        const apiPath = '/health/db';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get pubsub
+     *
+     * Check the Appconda pub-sub servers are up and connection is successful.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthStatus>}
+     */
+    async getPubSub() {
+        const apiPath = '/health/pubsub';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get queue
+     *
+     * Check the Appconda queue messaging servers are up and connection is successful.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthStatus>}
+     */
+    async getQueue() {
+        const apiPath = '/health/queue';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get builds queue
+     *
+     * Get the number of builds that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueBuilds(threshold) {
+        const apiPath = '/health/queue/builds';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get certificates queue
+     *
+     * Get the number of certificates that are waiting to be issued against [Letsencrypt](https://letsencrypt.org/) in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueCertificates(threshold) {
+        const apiPath = '/health/queue/certificates';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get databases queue
+     *
+     * Get the number of database changes that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {string} name
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueDatabases(name, threshold) {
+        const apiPath = '/health/queue/databases';
+        const payload = {};
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get deletes queue
+     *
+     * Get the number of background destructive changes that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueDeletes(threshold) {
+        const apiPath = '/health/queue/deletes';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get number of failed queue jobs
+     *
+     * Returns the amount of failed jobs in a given queue.
+
+     *
+     * @param {Name} name
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getFailedJobs(name, threshold) {
+        if (typeof name === 'undefined') {
+            throw new AppcondaException('Missing required parameter: "name"');
+        }
+        const apiPath = '/health/queue/failed/{name}'.replace('{name}', name);
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get functions queue
+     *
+     * Get the number of function executions that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueFunctions(threshold) {
+        const apiPath = '/health/queue/functions';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get logs queue
+     *
+     * Get the number of logs that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueLogs(threshold) {
+        const apiPath = '/health/queue/logs';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get mails queue
+     *
+     * Get the number of mails that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueMails(threshold) {
+        const apiPath = '/health/queue/mails';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get messaging queue
+     *
+     * Get the number of messages that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueMessaging(threshold) {
+        const apiPath = '/health/queue/messaging';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get migrations queue
+     *
+     * Get the number of migrations that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueMigrations(threshold) {
+        const apiPath = '/health/queue/migrations';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get usage queue
+     *
+     * Get the number of metrics that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueUsage(threshold) {
+        const apiPath = '/health/queue/usage';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get usage dump queue
+     *
+     * Get the number of projects containing metrics that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueUsageDump(threshold) {
+        const apiPath = '/health/queue/usage-dump';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get webhooks queue
+     *
+     * Get the number of webhooks that are waiting to be processed in the Appconda internal queue server.
+     *
+     * @param {number} threshold
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthQueue>}
+     */
+    async getQueueWebhooks(threshold) {
+        const apiPath = '/health/queue/webhooks';
+        const payload = {};
+        if (typeof threshold !== 'undefined') {
+            payload['threshold'] = threshold;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get storage
+     *
+     * Check the Appconda storage device is up and connection is successful.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthStatus>}
+     */
+    async getStorage() {
+        const apiPath = '/health/storage';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get local storage
+     *
+     * Check the Appconda local storage device is up and connection is successful.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthStatus>}
+     */
+    async getStorageLocal() {
+        const apiPath = '/health/storage/local';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+    /**
+     * Get time
+     *
+     * Check the Appconda server time is synced with Google remote NTP server. We use this technology to smoothly handle leap seconds with no disruptive events. The [Network Time Protocol](https://en.wikipedia.org/wiki/Network_Time_Protocol) (NTP) is used by hundreds of millions of computers and devices to synchronize their clocks over the Internet. If your computer sets its own clock, it likely uses NTP.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.HealthTime>}
+     */
+    async getTime() {
+        const apiPath = '/health/time';
+        const payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+        };
+        return await this.client.call('get', uri, apiHeaders, payload);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health.js","sourceRoot":"","sources":["../../src/services/health.ts"],"names":[],"mappings":"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","sourcesContent":["import { AppcondaException, Client, type Payload, UploadProgress } from '../client';\nimport type { Models } from '../models';\nimport { Name } from '../enums/name';\n\nexport class Health {\n    client: Client;\n\n    constructor(client: Client) {\n        this.client = client;\n    }\n\n    /**\n     * Get HTTP\n     *\n     * Check the Appconda HTTP server is up and responsive.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthStatus>}\n     */\n    async get(): Promise<Models.HealthStatus> {\n        const apiPath = '/health';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get antivirus\n     *\n     * Check the Appconda Antivirus server is up and connection is successful.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthAntivirus>}\n     */\n    async getAntivirus(): Promise<Models.HealthAntivirus> {\n        const apiPath = '/health/anti-virus';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get cache\n     *\n     * Check the Appconda in-memory cache servers are up and connection is successful.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthStatus>}\n     */\n    async getCache(): Promise<Models.HealthStatus> {\n        const apiPath = '/health/cache';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get the SSL certificate for a domain\n     *\n     * Get the SSL certificate for a domain\n     *\n     * @param {string} domain\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthCertificate>}\n     */\n    async getCertificate(domain?: string): Promise<Models.HealthCertificate> {\n        const apiPath = '/health/certificate';\n        const payload: Payload = {};\n        if (typeof domain !== 'undefined') {\n            payload['domain'] = domain;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get DB\n     *\n     * Check the Appconda database servers are up and connection is successful.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthStatus>}\n     */\n    async getDB(): Promise<Models.HealthStatus> {\n        const apiPath = '/health/db';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get pubsub\n     *\n     * Check the Appconda pub-sub servers are up and connection is successful.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthStatus>}\n     */\n    async getPubSub(): Promise<Models.HealthStatus> {\n        const apiPath = '/health/pubsub';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get queue\n     *\n     * Check the Appconda queue messaging servers are up and connection is successful.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthStatus>}\n     */\n    async getQueue(): Promise<Models.HealthStatus> {\n        const apiPath = '/health/queue';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get builds queue\n     *\n     * Get the number of builds that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueBuilds(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/builds';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get certificates queue\n     *\n     * Get the number of certificates that are waiting to be issued against [Letsencrypt](https://letsencrypt.org/) in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueCertificates(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/certificates';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get databases queue\n     *\n     * Get the number of database changes that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {string} name\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueDatabases(name?: string, threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/databases';\n        const payload: Payload = {};\n        if (typeof name !== 'undefined') {\n            payload['name'] = name;\n        }\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get deletes queue\n     *\n     * Get the number of background destructive changes that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueDeletes(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/deletes';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get number of failed queue jobs\n     *\n     * Returns the amount of failed jobs in a given queue.\n\n     *\n     * @param {Name} name\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getFailedJobs(name: Name, threshold?: number): Promise<Models.HealthQueue> {\n        if (typeof name === 'undefined') {\n            throw new AppcondaException('Missing required parameter: \"name\"');\n        }\n        const apiPath = '/health/queue/failed/{name}'.replace('{name}', name);\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get functions queue\n     *\n     * Get the number of function executions that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueFunctions(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/functions';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get logs queue\n     *\n     * Get the number of logs that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueLogs(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/logs';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get mails queue\n     *\n     * Get the number of mails that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueMails(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/mails';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get messaging queue\n     *\n     * Get the number of messages that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueMessaging(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/messaging';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get migrations queue\n     *\n     * Get the number of migrations that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueMigrations(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/migrations';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get usage queue\n     *\n     * Get the number of metrics that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueUsage(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/usage';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get usage dump queue\n     *\n     * Get the number of projects containing metrics that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueUsageDump(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/usage-dump';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get webhooks queue\n     *\n     * Get the number of webhooks that are waiting to be processed in the Appconda internal queue server.\n     *\n     * @param {number} threshold\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthQueue>}\n     */\n    async getQueueWebhooks(threshold?: number): Promise<Models.HealthQueue> {\n        const apiPath = '/health/queue/webhooks';\n        const payload: Payload = {};\n        if (typeof threshold !== 'undefined') {\n            payload['threshold'] = threshold;\n        }\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get storage\n     *\n     * Check the Appconda storage device is up and connection is successful.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthStatus>}\n     */\n    async getStorage(): Promise<Models.HealthStatus> {\n        const apiPath = '/health/storage';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get local storage\n     *\n     * Check the Appconda local storage device is up and connection is successful.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthStatus>}\n     */\n    async getStorageLocal(): Promise<Models.HealthStatus> {\n        const apiPath = '/health/storage/local';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n    /**\n     * Get time\n     *\n     * Check the Appconda server time is synced with Google remote NTP server. We use this technology to smoothly handle leap seconds with no disruptive events. The [Network Time Protocol](https://en.wikipedia.org/wiki/Network_Time_Protocol) (NTP) is used by hundreds of millions of computers and devices to synchronize their clocks over the Internet. If your computer sets its own clock, it likely uses NTP.\n     *\n     * @throws {AppcondaException}\n     * @returns {Promise<Models.HealthTime>}\n     */\n    async getTime(): Promise<Models.HealthTime> {\n        const apiPath = '/health/time';\n        const payload: Payload = {};\n        const uri = new URL(this.client.config.endpoint + apiPath);\n\n        const apiHeaders: { [header: string]: string } = {\n            'content-type': 'application/json',\n        }\n\n        return await this.client.call(\n            'get',\n            uri,\n            apiHeaders,\n            payload,\n        );\n    }\n}\n"]}

package/dist/services/locale.d.ts

@@ -0,0 +1,80 @@
+import { Client } from '../client';
+import type { Models } from '../models';
+export declare class Locale {
+    client: Client;
+    constructor(client: Client);
+    /**
+     * Get user locale
+     *
+     * Get the current user location based on IP. Returns an object with user country code, country name, continent name, continent code, ip address and suggested currency. You can use the locale header to get the data in a supported language.
+
+([IP Geolocation by DB-IP](https://db-ip.com))
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.Locale>}
+     */
+    get(): Promise<Models.Locale>;
+    /**
+     * List Locale Codes
+     *
+     * List of all locale codes in [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes).
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.LocaleCodeList>}
+     */
+    listCodes(): Promise<Models.LocaleCodeList>;
+    /**
+     * List continents
+     *
+     * List of all continents. You can use the locale header to get the data in a supported language.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.ContinentList>}
+     */
+    listContinents(): Promise<Models.ContinentList>;
+    /**
+     * List countries
+     *
+     * List of all countries. You can use the locale header to get the data in a supported language.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.CountryList>}
+     */
+    listCountries(): Promise<Models.CountryList>;
+    /**
+     * List EU countries
+     *
+     * List of all countries that are currently members of the EU. You can use the locale header to get the data in a supported language.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.CountryList>}
+     */
+    listCountriesEU(): Promise<Models.CountryList>;
+    /**
+     * List countries phone codes
+     *
+     * List of all countries phone codes. You can use the locale header to get the data in a supported language.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.PhoneList>}
+     */
+    listCountriesPhones(): Promise<Models.PhoneList>;
+    /**
+     * List currencies
+     *
+     * List of all currencies, including currency symbol, name, plural, and decimal digits for all major and minor currencies. You can use the locale header to get the data in a supported language.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.CurrencyList>}
+     */
+    listCurrencies(): Promise<Models.CurrencyList>;
+    /**
+     * List languages
+     *
+     * List of all languages classified by ISO 639-1 including 2-letter code, name in English, and name in the respective language.
+     *
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.LanguageList>}
+     */
+    listLanguages(): Promise<Models.LanguageList>;
+}