@appwrite.io/console 17.0.0 → 18.0.0

package/dist/cjs/sdk.js

@@ -1,6 +1,8 @@
 'use strict';
 
 var JSONbigModule = require('json-bigint');
+var buffer = require('buffer');
+var mqtt = require('mqtt');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -644,6 +646,8 @@ class Client {
         this.config = {
             endpoint: 'https://cloud.appwrite.io/v1',
             endpointRealtime: '',
+            endpointPush: '',
+            pushClientId: '',
             project: '',
             key: '',
             organization: '',
@@ -667,8 +671,8 @@ class Client {
             'x-sdk-name': 'Console',
             'x-sdk-platform': 'console',
             'x-sdk-language': 'web',
-            'x-sdk-version': '17.0.0',
-            'X-Appwrite-Response-Format': '2.2.0',
+            'x-sdk-version': '18.0.0',
+            'X-Appwrite-Response-Format': '2.3.0',
         };
         this.realtime = {
             socket: undefined,
@@ -909,6 +913,44 @@ class Client {
         this.config.endpointRealtime = endpointRealtime;
         return this;
     }
+    /**
+     * Set Push Endpoint
+     *
+     * The MQTT-over-WebSocket URL the AppwritePush service connects to.
+     *
+     * @param {string} endpointPush
+     *
+     * @returns {this}
+     */
+    setPushEndpoint(endpointPush) {
+        if (!endpointPush || typeof endpointPush !== 'string') {
+            throw new AppwriteException('Endpoint must be a valid string');
+        }
+        if (!endpointPush.startsWith('ws://') &&
+            !endpointPush.startsWith('wss://')) {
+            throw new AppwriteException('Invalid push endpoint URL: ' + endpointPush);
+        }
+        this.config.endpointPush = endpointPush;
+        return this;
+    }
+    /**
+     * Set Push Client Id
+     *
+     * A stable client id for the AppwritePush service. The broker keys its
+     * offline-replay cursor on this id, so pass a stable value to resume replay across
+     * reloads/restarts. Defaults to a per-connection id when unset.
+     *
+     * @param {string} pushClientId
+     *
+     * @returns {this}
+     */
+    setPushClientId(pushClientId) {
+        if (!pushClientId || typeof pushClientId !== 'string') {
+            throw new AppwriteException('Client id must be a valid string');
+        }
+        this.config.pushClientId = pushClientId;
+        return this;
+    }
     /**
      * Set self-signed
      *
@@ -1239,10 +1281,8 @@ class Client {
         const options = {
             method,
             headers,
+            credentials: this.config.credentials,
         };
-        if (headers['X-Appwrite-Dev-Key'] === undefined) {
-            options.credentials = this.config.credentials;
-        }
         if (method === 'GET') {
             for (const [key, value] of Object.entries(Client.flatten(params))) {
                 url.searchParams.append(key, value);
@@ -1281,7 +1321,7 @@ class Client {
             var _a;
             const [fileParam, file] = (_a = Object.entries(originalPayload).find(([_, value]) => value instanceof File)) !== null && _a !== void 0 ? _a : [];
             if (!file || !fileParam) {
-                throw new Error('File not found in payload');
+                return yield this.call(method, url, headers, originalPayload);
             }
             if (file.size <= Client.CHUNK_SIZE) {
                 return yield this.call(method, url, headers, originalPayload);
@@ -3228,6 +3268,85 @@ class Account {
         };
         return this.client.call('put', uri, apiHeaders, payload);
     }
+    createRecoveryOTP(paramsOrFirst, ...rest) {
+        let params;
+        if (paramsOrFirst &&
+            typeof paramsOrFirst === 'object' &&
+            !Array.isArray(paramsOrFirst)) {
+            params = (paramsOrFirst || {});
+        }
+        else {
+            params = {
+                email: paramsOrFirst,
+                phrase: rest[0],
+            };
+        }
+        const email = params.email;
+        const phrase = params.phrase;
+        if (typeof email === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "email"');
+        }
+        const apiPath = '/account/recovery/otp';
+        const payload = {};
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+        if (typeof phrase !== 'undefined') {
+            payload['phrase'] = phrase;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'X-Appwrite-Project': this.client.config.project,
+            'content-type': 'application/json',
+            accept: 'application/json',
+        };
+        return this.client.call('post', uri, apiHeaders, payload);
+    }
+    updateRecoveryOTP(paramsOrFirst, ...rest) {
+        let params;
+        if (paramsOrFirst &&
+            typeof paramsOrFirst === 'object' &&
+            !Array.isArray(paramsOrFirst)) {
+            params = (paramsOrFirst || {});
+        }
+        else {
+            params = {
+                userId: paramsOrFirst,
+                secret: rest[0],
+                password: rest[1],
+            };
+        }
+        const userId = params.userId;
+        const secret = params.secret;
+        const password = params.password;
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+        if (typeof secret === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "secret"');
+        }
+        if (typeof password === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "password"');
+        }
+        const apiPath = '/account/recovery/otp';
+        const payload = {};
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+        if (typeof secret !== 'undefined') {
+            payload['secret'] = secret;
+        }
+        if (typeof password !== 'undefined') {
+            payload['password'] = password;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'X-Appwrite-Project': this.client.config.project,
+            'content-type': 'application/json',
+            accept: 'application/json',
+        };
+        return this.client.call('put', uri, apiHeaders, payload);
+    }
     /**
      * Get the list of active sessions across different devices for the currently logged in user.
      *
@@ -15741,6 +15860,171 @@ class Graphql {
     }
 }
 
+class Growth {
+    constructor(client) {
+        this.client = client;
+    }
+    createConversation(paramsOrFirst, ...rest) {
+        let params;
+        let onProgress;
+        if (paramsOrFirst &&
+            typeof paramsOrFirst === 'object' &&
+            !Array.isArray(paramsOrFirst) &&
+            ('type' in paramsOrFirst ||
+                'email' in paramsOrFirst ||
+                'name' in paramsOrFirst ||
+                'subject' in paramsOrFirst ||
+                'message' in paramsOrFirst ||
+                'organizationId' in paramsOrFirst ||
+                'projectId' in paramsOrFirst ||
+                'attributes' in paramsOrFirst ||
+                'attachment' in paramsOrFirst ||
+                'onProgress' in paramsOrFirst)) {
+            params = (paramsOrFirst || {});
+            onProgress = paramsOrFirst === null || paramsOrFirst === void 0 ? void 0 : paramsOrFirst.onProgress;
+        }
+        else {
+            params = {
+                type: paramsOrFirst,
+                email: rest[0],
+                name: rest[1],
+                subject: rest[2],
+                message: rest[3],
+                organizationId: rest[4],
+                projectId: rest[5],
+                attributes: rest[6],
+                attachment: rest[7],
+            };
+            onProgress = rest[8];
+        }
+        const type = params.type;
+        const email = params.email;
+        const name = params.name;
+        const subject = params.subject;
+        const message = params.message;
+        const organizationId = params.organizationId;
+        const projectId = params.projectId;
+        const attributes = params.attributes;
+        const attachment = params.attachment;
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+        const apiPath = '/growth/conversations';
+        const payload = {};
+        if (typeof type !== 'undefined') {
+            payload['type'] = type;
+        }
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
+        if (typeof subject !== 'undefined') {
+            payload['subject'] = subject;
+        }
+        if (typeof message !== 'undefined') {
+            payload['message'] = message;
+        }
+        if (typeof organizationId !== 'undefined') {
+            payload['organizationId'] = organizationId;
+        }
+        if (typeof projectId !== 'undefined') {
+            payload['projectId'] = projectId;
+        }
+        if (typeof attributes !== 'undefined') {
+            payload['attributes'] = attributes;
+        }
+        if (typeof attachment !== 'undefined') {
+            payload['attachment'] = attachment;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'X-Appwrite-Project': this.client.config.project,
+            'content-type': 'multipart/form-data',
+            accept: 'application/json',
+        };
+        return this.client.chunkedUpload('post', uri, apiHeaders, payload, onProgress);
+    }
+    createInstallation(paramsOrFirst, ...rest) {
+        let params;
+        if ((typeof paramsOrFirst === 'undefined' && rest.length === 0) ||
+            (paramsOrFirst &&
+                typeof paramsOrFirst === 'object' &&
+                !Array.isArray(paramsOrFirst))) {
+            params = (paramsOrFirst || {});
+        }
+        else {
+            params = {
+                email: paramsOrFirst,
+                name: rest[0],
+                version: rest[1],
+                domain: rest[2],
+                database: rest[3],
+                hostIp: rest[4],
+                userAgent: rest[5],
+                os: rest[6],
+                arch: rest[7],
+                cpus: rest[8],
+                ram: rest[9],
+            };
+        }
+        const email = params.email;
+        const name = params.name;
+        const version = params.version;
+        const domain = params.domain;
+        const database = params.database;
+        const hostIp = params.hostIp;
+        const userAgent = params.userAgent;
+        const os = params.os;
+        const arch = params.arch;
+        const cpus = params.cpus;
+        const ram = params.ram;
+        const apiPath = '/growth/installations';
+        const payload = {};
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
+        if (typeof version !== 'undefined') {
+            payload['version'] = version;
+        }
+        if (typeof domain !== 'undefined') {
+            payload['domain'] = domain;
+        }
+        if (typeof database !== 'undefined') {
+            payload['database'] = database;
+        }
+        if (typeof hostIp !== 'undefined') {
+            payload['hostIp'] = hostIp;
+        }
+        if (typeof userAgent !== 'undefined') {
+            payload['userAgent'] = userAgent;
+        }
+        if (typeof os !== 'undefined') {
+            payload['os'] = os;
+        }
+        if (typeof arch !== 'undefined') {
+            payload['arch'] = arch;
+        }
+        if (typeof cpus !== 'undefined') {
+            payload['cpus'] = cpus;
+        }
+        if (typeof ram !== 'undefined') {
+            payload['ram'] = ram;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'X-Appwrite-Project': this.client.config.project,
+            'content-type': 'application/json',
+            accept: 'application/json',
+        };
+        return this.client.call('post', uri, apiHeaders, payload);
+    }
+}
+
 class Locale {
     constructor(client) {
         this.client = client;
@@ -16065,6 +16349,47 @@ class Manager {
         };
         return this.client.call('delete', uri, apiHeaders, payload);
     }
+    updateOrganizationStatus(paramsOrFirst, ...rest) {
+        let params;
+        if (paramsOrFirst &&
+            typeof paramsOrFirst === 'object' &&
+            !Array.isArray(paramsOrFirst)) {
+            params = (paramsOrFirst || {});
+        }
+        else {
+            params = {
+                teamId: paramsOrFirst,
+                status: rest[0],
+                reason: rest[1],
+            };
+        }
+        const teamId = params.teamId;
+        const status = params.status;
+        const reason = params.reason;
+        if (typeof teamId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "teamId"');
+        }
+        if (typeof status === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "status"');
+        }
+        const apiPath = '/manager/organizations/status';
+        const payload = {};
+        if (typeof teamId !== 'undefined') {
+            payload['teamId'] = teamId;
+        }
+        if (typeof status !== 'undefined') {
+            payload['status'] = status;
+        }
+        if (typeof reason !== 'undefined') {
+            payload['reason'] = reason;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'content-type': 'application/json',
+            accept: 'application/json',
+        };
+        return this.client.call('patch', uri, apiHeaders, payload);
+    }
     updateUserStatus(paramsOrFirst, ...rest) {
         let params;
         if (paramsOrFirst &&
@@ -16168,9 +16493,11 @@ class Messaging {
                 cc: rest[5],
                 bcc: rest[6],
                 attachments: rest[7],
-                draft: rest[8],
-                html: rest[9],
-                scheduledAt: rest[10],
+                replyToEmail: rest[8],
+                replyToName: rest[9],
+                draft: rest[10],
+                html: rest[11],
+                scheduledAt: rest[12],
             };
         }
         const messageId = params.messageId;
@@ -16182,6 +16509,8 @@ class Messaging {
         const cc = params.cc;
         const bcc = params.bcc;
         const attachments = params.attachments;
+        const replyToEmail = params.replyToEmail;
+        const replyToName = params.replyToName;
         const draft = params.draft;
         const html = params.html;
         const scheduledAt = params.scheduledAt;
@@ -16223,6 +16552,12 @@ class Messaging {
         if (typeof attachments !== 'undefined') {
             payload['attachments'] = attachments;
         }
+        if (typeof replyToEmail !== 'undefined') {
+            payload['replyToEmail'] = replyToEmail;
+        }
+        if (typeof replyToName !== 'undefined') {
+            payload['replyToName'] = replyToName;
+        }
         if (typeof draft !== 'undefined') {
             payload['draft'] = draft;
         }
@@ -16259,8 +16594,10 @@ class Messaging {
                 html: rest[6],
                 cc: rest[7],
                 bcc: rest[8],
-                scheduledAt: rest[9],
-                attachments: rest[10],
+                replyToEmail: rest[9],
+                replyToName: rest[10],
+                scheduledAt: rest[11],
+                attachments: rest[12],
             };
         }
         const messageId = params.messageId;
@@ -16273,6 +16610,8 @@ class Messaging {
         const html = params.html;
         const cc = params.cc;
         const bcc = params.bcc;
+        const replyToEmail = params.replyToEmail;
+        const replyToName = params.replyToName;
         const scheduledAt = params.scheduledAt;
         const attachments = params.attachments;
         if (typeof messageId === 'undefined' || messageId === '') {
@@ -16307,6 +16646,12 @@ class Messaging {
         if (typeof bcc !== 'undefined') {
             payload['bcc'] = bcc;
         }
+        if (typeof replyToEmail !== 'undefined') {
+            payload['replyToEmail'] = replyToEmail;
+        }
+        if (typeof replyToName !== 'undefined') {
+            payload['replyToName'] = replyToName;
+        }
         if (typeof scheduledAt !== 'undefined') {
             payload['scheduledAt'] = scheduledAt;
         }
@@ -25384,31 +25729,6 @@ class Organizations {
         };
         return this.client.call('get', uri, apiHeaders, payload);
     }
-    getEstimation(paramsOrFirst) {
-        let params;
-        if (paramsOrFirst &&
-            typeof paramsOrFirst === 'object' &&
-            !Array.isArray(paramsOrFirst)) {
-            params = (paramsOrFirst || {});
-        }
-        else {
-            params = {
-                organizationId: paramsOrFirst,
-            };
-        }
-        const organizationId = params.organizationId;
-        if (typeof organizationId === 'undefined' || organizationId === '') {
-            throw new AppwriteException('Missing required parameter: "organizationId"');
-        }
-        const apiPath = '/organizations/{organizationId}/estimations'.replace('{organizationId}', encodeURIComponent(String(organizationId)));
-        const payload = {};
-        const uri = new URL(this.client.config.endpoint + apiPath);
-        const apiHeaders = {
-            'X-Appwrite-Project': this.client.config.project,
-            accept: 'application/json',
-        };
-        return this.client.call('get', uri, apiHeaders, payload);
-    }
     estimationDeleteOrganization(paramsOrFirst) {
         let params;
         if (paramsOrFirst &&
@@ -28626,12 +28946,14 @@ class Project {
                 clientId: paramsOrFirst,
                 clientSecret: rest[0],
                 endpoint: rest[1],
-                enabled: rest[2],
+                prompt: rest[2],
+                enabled: rest[3],
             };
         }
         const clientId = params.clientId;
         const clientSecret = params.clientSecret;
         const endpoint = params.endpoint;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/auth0';
         const payload = {};
@@ -28644,6 +28966,9 @@ class Project {
         if (typeof endpoint !== 'undefined') {
             payload['endpoint'] = endpoint;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -28931,11 +29256,13 @@ class Project {
             params = {
                 clientId: paramsOrFirst,
                 clientSecret: rest[0],
-                enabled: rest[1],
+                prompt: rest[1],
+                enabled: rest[2],
             };
         }
         const clientId = params.clientId;
         const clientSecret = params.clientSecret;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/discord';
         const payload = {};
@@ -28945,6 +29272,9 @@ class Project {
         if (typeof clientSecret !== 'undefined') {
             payload['clientSecret'] = clientSecret;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -29195,11 +29525,13 @@ class Project {
             params = {
                 clientId: paramsOrFirst,
                 clientSecret: rest[0],
-                enabled: rest[1],
+                prompt: rest[1],
+                enabled: rest[2],
             };
         }
         const clientId = params.clientId;
         const clientSecret = params.clientSecret;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/github';
         const payload = {};
@@ -29209,6 +29541,9 @@ class Project {
         if (typeof clientSecret !== 'undefined') {
             payload['clientSecret'] = clientSecret;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -29363,11 +29698,13 @@ class Project {
             params = {
                 clientId: paramsOrFirst,
                 clientSecret: rest[0],
-                enabled: rest[1],
+                prompt: rest[1],
+                enabled: rest[2],
             };
         }
         const clientId = params.clientId;
         const clientSecret = params.clientSecret;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/kakao';
         const payload = {};
@@ -29377,6 +29714,9 @@ class Project {
         if (typeof clientSecret !== 'undefined') {
             payload['clientSecret'] = clientSecret;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -29522,12 +29862,14 @@ class Project {
                 applicationId: paramsOrFirst,
                 applicationSecret: rest[0],
                 tenant: rest[1],
-                enabled: rest[2],
+                prompt: rest[2],
+                enabled: rest[3],
             };
         }
         const applicationId = params.applicationId;
         const applicationSecret = params.applicationSecret;
         const tenant = params.tenant;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/microsoft';
         const payload = {};
@@ -29540,6 +29882,9 @@ class Project {
         if (typeof tenant !== 'undefined') {
             payload['tenant'] = tenant;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -29669,13 +30014,15 @@ class Project {
                 clientSecret: rest[0],
                 domain: rest[1],
                 authorizationServerId: rest[2],
-                enabled: rest[3],
+                prompt: rest[3],
+                enabled: rest[4],
             };
         }
         const clientId = params.clientId;
         const clientSecret = params.clientSecret;
         const domain = params.domain;
         const authorizationServerId = params.authorizationServerId;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/okta';
         const payload = {};
@@ -29691,6 +30038,9 @@ class Project {
         if (typeof authorizationServerId !== 'undefined') {
             payload['authorizationServerId'] = authorizationServerId;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -29862,11 +30212,13 @@ class Project {
             params = {
                 customerKey: paramsOrFirst,
                 customerSecret: rest[0],
-                enabled: rest[1],
+                prompt: rest[1],
+                enabled: rest[2],
             };
         }
         const customerKey = params.customerKey;
         const customerSecret = params.customerSecret;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/salesforce';
         const payload = {};
@@ -29876,6 +30228,9 @@ class Project {
         if (typeof customerSecret !== 'undefined') {
             payload['customerSecret'] = customerSecret;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -30306,11 +30661,13 @@ class Project {
             params = {
                 clientId: paramsOrFirst,
                 clientSecret: rest[0],
-                enabled: rest[1],
+                prompt: rest[1],
+                enabled: rest[2],
             };
         }
         const clientId = params.clientId;
         const clientSecret = params.clientSecret;
+        const prompt = params.prompt;
         const enabled = params.enabled;
         const apiPath = '/project/oauth2/zoho';
         const payload = {};
@@ -30320,6 +30677,9 @@ class Project {
         if (typeof clientSecret !== 'undefined') {
             payload['clientSecret'] = clientSecret;
         }
+        if (typeof prompt !== 'undefined') {
+            payload['prompt'] = prompt;
+        }
         if (typeof enabled !== 'undefined') {
             payload['enabled'] = enabled;
         }
@@ -37407,6 +37767,55 @@ class TablesDB {
         };
         return this.client.call('post', uri, apiHeaders, payload);
     }
+    updateRelationshipColumn(paramsOrFirst, ...rest) {
+        let params;
+        if (paramsOrFirst &&
+            typeof paramsOrFirst === 'object' &&
+            !Array.isArray(paramsOrFirst)) {
+            params = (paramsOrFirst || {});
+        }
+        else {
+            params = {
+                databaseId: paramsOrFirst,
+                tableId: rest[0],
+                key: rest[1],
+                onDelete: rest[2],
+                newKey: rest[3],
+            };
+        }
+        const databaseId = params.databaseId;
+        const tableId = params.tableId;
+        const key = params.key;
+        const onDelete = params.onDelete;
+        const newKey = params.newKey;
+        if (typeof databaseId === 'undefined' || databaseId === '') {
+            throw new AppwriteException('Missing required parameter: "databaseId"');
+        }
+        if (typeof tableId === 'undefined' || tableId === '') {
+            throw new AppwriteException('Missing required parameter: "tableId"');
+        }
+        if (typeof key === 'undefined' || key === '') {
+            throw new AppwriteException('Missing required parameter: "key"');
+        }
+        const apiPath = '/tablesdb/{databaseId}/tables/{tableId}/columns/relationship/{key}'
+            .replace('{databaseId}', encodeURIComponent(String(databaseId)))
+            .replace('{tableId}', encodeURIComponent(String(tableId)))
+            .replace('{key}', encodeURIComponent(String(key)));
+        const payload = {};
+        if (typeof onDelete !== 'undefined') {
+            payload['onDelete'] = onDelete;
+        }
+        if (typeof newKey !== 'undefined') {
+            payload['newKey'] = newKey;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+        const apiHeaders = {
+            'X-Appwrite-Project': this.client.config.project,
+            'content-type': 'application/json',
+            accept: 'application/json',
+        };
+        return this.client.call('patch', uri, apiHeaders, payload);
+    }
     createStringColumn(paramsOrFirst, ...rest) {
         let params;
         if (paramsOrFirst &&
@@ -38001,55 +38410,6 @@ class TablesDB {
         };
         return this.client.call('delete', uri, apiHeaders, payload);
     }
-    updateRelationshipColumn(paramsOrFirst, ...rest) {
-        let params;
-        if (paramsOrFirst &&
-            typeof paramsOrFirst === 'object' &&
-            !Array.isArray(paramsOrFirst)) {
-            params = (paramsOrFirst || {});
-        }
-        else {
-            params = {
-                databaseId: paramsOrFirst,
-                tableId: rest[0],
-                key: rest[1],
-                onDelete: rest[2],
-                newKey: rest[3],
-            };
-        }
-        const databaseId = params.databaseId;
-        const tableId = params.tableId;
-        const key = params.key;
-        const onDelete = params.onDelete;
-        const newKey = params.newKey;
-        if (typeof databaseId === 'undefined' || databaseId === '') {
-            throw new AppwriteException('Missing required parameter: "databaseId"');
-        }
-        if (typeof tableId === 'undefined' || tableId === '') {
-            throw new AppwriteException('Missing required parameter: "tableId"');
-        }
-        if (typeof key === 'undefined' || key === '') {
-            throw new AppwriteException('Missing required parameter: "key"');
-        }
-        const apiPath = '/tablesdb/{databaseId}/tables/{tableId}/columns/{key}/relationship'
-            .replace('{databaseId}', encodeURIComponent(String(databaseId)))
-            .replace('{tableId}', encodeURIComponent(String(tableId)))
-            .replace('{key}', encodeURIComponent(String(key)));
-        const payload = {};
-        if (typeof onDelete !== 'undefined') {
-            payload['onDelete'] = onDelete;
-        }
-        if (typeof newKey !== 'undefined') {
-            payload['newKey'] = newKey;
-        }
-        const uri = new URL(this.client.config.endpoint + apiPath);
-        const apiHeaders = {
-            'X-Appwrite-Project': this.client.config.project,
-            'content-type': 'application/json',
-            accept: 'application/json',
-        };
-        return this.client.call('patch', uri, apiHeaders, payload);
-    }
     listIndexes(paramsOrFirst, ...rest) {
         let params;
         if (paramsOrFirst &&
@@ -45290,6 +45650,571 @@ class Realtime {
     }
 }
 
+// Fixed connection tuning — not exposed as options.
+const KEEP_ALIVE_SECONDS = 60;
+const RECONNECT_PERIOD_MS = 2000;
+/**
+ * Appwrite native push service — the Realtime analog over an MQTT broker, without
+ * FCM or APNS. In the browser the transport is MQTT 5 over WebSocket: while the page is
+ * open the connection stays up and each message is handed to your callback, and a
+ * subscription may also opt into a browser notification per message.
+ *
+ * The connection has no tunables — it always keeps its session (clean start off) so the
+ * broker can redeliver missed messages, and reliability is chosen per subscription via
+ * `retry`. `subscribe` opens the connection lazily and returns a
+ * {@link PushSubscription} handle (unlike Realtime's bare unsubscribe callable — Push
+ * carries per-subscription state). The credential is read off the client — set a JWT or
+ * session on it (`Client.setJWT` / `Client.setSession`), the same way every other service
+ * reads auth.
+ *
+ *     const client = new Client().setEndpoint(...).setProject(...).setJWT(jwt);
+ *     const push = new Push(client);
+ *     const sub = await push.subscribe('user/123/#', (m) =>
+ *       console.log(m.topic, m.data),
+ *     );
+ *     // sub.update({ background: true }); sub.unsubscribe();
+ */
+class Push extends Service {
+    constructor(client) {
+        super(client);
+        this.mqtt = null;
+        this.connecting = null;
+        /** Set once the first CONNACK lands, so 'connect' events after are reconnects. */
+        this.everConnected = false;
+        /** Errors already handed to onError, so one failure is reported once. */
+        this.reported = new WeakSet();
+        /** mqtt.js connect errors mapped to the error handed out for them (see connectError). */
+        this.connectErrors = new WeakMap();
+        /** True while the first connect is in flight: its errors go to the waiting caller. */
+        this.opening = false;
+        // Local id -> subscription state. The id is never sent to the broker; it only lets
+        // the same topic carry more than one callback (each with its own options).
+        /**
+         * The client id when the credential names no user (and none was set): random, but kept for
+         * this instance so reconnects resume the same broker session.
+         */
+        this.fallbackClientId = randomId();
+        this.subscriptions = new Map();
+    }
+    // The broker subscription for a filter uses the highest QoS any local subscription on
+    // it wants, so a QoS-0 subscription never downgrades a QoS-1 one sharing the filter.
+    effectiveQos(filter) {
+        for (const sub of this.subscriptions.values()) {
+            if (sub.topic === filter && sub.qos === 1) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    /** Register a callback invoked when the connection opens (CONNACK success). */
+    onOpen(callback) {
+        this.onOpenCb = callback;
+        return this;
+    }
+    /** Register a callback invoked when the connection closes. */
+    onClose(callback) {
+        this.onCloseCb = callback;
+        return this;
+    }
+    /** Register a callback invoked on a connection error. */
+    onError(callback) {
+        this.onErrorCb = callback;
+        return this;
+    }
+    /**
+     * The signed-in user's own topic, `users/<userId>`, for a topic-less subscribe. The id comes
+     * from the credential the connection authenticates with: the JWT when one is set (never
+     * the session, which could belong to a different user), else the session.
+     */
+    userTopic() {
+        const { jwt, session } = this.client.config;
+        const userId = jwt ? userIdFromJwt(jwt) : userIdFromSession(session);
+        if (!userId) {
+            throw new Error('subscribe() without a topic needs a signed-in user: set a JWT or session on the client');
+        }
+        return `users/${userId}`;
+    }
+    /**
+     * Hand an error to the onError callback, once per error. These errors happen outside any
+     * call (reconnects, broker DISCONNECTs, background re-subscribes), so they are never
+     * thrown, which would crash the app from inside mqtt.js: with no callback registered
+     * they are logged, like Realtime does.
+     */
+    report(error) {
+        const err = toError(error);
+        if (this.reported.has(err)) {
+            return;
+        }
+        this.reported.add(err);
+        if (!this.onErrorCb) {
+            console.error('Appwrite Push error:', err);
+            return;
+        }
+        try {
+            this.onErrorCb(err);
+        }
+        catch (callbackError) {
+            console.error('Appwrite Push onError threw:', callbackError);
+        }
+    }
+    /**
+     * For a call that fails to its caller: report the error to onError when a callback is
+     * registered, then throw it to the caller, who can catch it.
+     */
+    fail(error) {
+        const err = toError(error);
+        if (this.onErrorCb) {
+            this.report(err);
+        }
+        throw err;
+    }
+    subscribe(topicsOrCallback_1, callbackOrOptions_1) {
+        return __awaiter(this, arguments, void 0, function* (topicsOrCallback, callbackOrOptions, topicOptions = {}) {
+            // Every failure reaches onError (when registered) and is thrown to the caller.
+            try {
+                return yield this.subscribeWith(topicsOrCallback, callbackOrOptions, topicOptions);
+            }
+            catch (err) {
+                this.fail(err);
+            }
+        });
+    }
+    subscribeWith(topicsOrCallback, callbackOrOptions, topicOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Topic-less form: subscribe(callback, options) targets the signed-in user's topic.
+            const userForm = typeof topicsOrCallback === 'function';
+            const topics = userForm ? this.userTopic() : topicsOrCallback;
+            const callback = (userForm ? topicsOrCallback : callbackOrOptions);
+            const options = (userForm ? (callbackOrOptions !== null && callbackOrOptions !== void 0 ? callbackOrOptions : {}) : topicOptions);
+            const topicList = (Array.isArray(topics) ? topics : [topics]).map((topic) => topic.toString());
+            // The user topic defaults to background delivery, like FCM/APNs; topics default off.
+            const background = (_a = options.background) !== null && _a !== void 0 ? _a : userForm;
+            const qos = ((_b = options.retry) !== null && _b !== void 0 ? _b : true) ? 1 : 0;
+            if (background) {
+                this.requestNotificationPermission();
+            }
+            const client = yield this.connect();
+            const ids = [];
+            const acks = [];
+            for (const topic of topicList) {
+                const id = randomId();
+                ids.push(id);
+                this.subscriptions.set(id, {
+                    topic,
+                    callback,
+                    background,
+                    title: options.title,
+                    qos,
+                });
+                acks.push(new Promise((resolve, reject) => {
+                    client.subscribe(topic, { qos: this.effectiveQos(topic) }, (err) => (err ? reject(err) : resolve()));
+                }));
+            }
+            const unsubscribe = () => {
+                var _a;
+                // Filters whose removed sub was QoS 1: their effective QoS may now drop.
+                const maybeDowngrade = new Set();
+                for (const id of ids) {
+                    const entry = this.subscriptions.get(id);
+                    this.subscriptions.delete(id);
+                    if ((entry === null || entry === void 0 ? void 0 : entry.qos) === 1) {
+                        maybeDowngrade.add(entry.topic);
+                    }
+                    // Only unsubscribe the broker filter once its last local callback is gone.
+                    const stillUsed = [...this.subscriptions.values()].some((s) => s.topic === (entry === null || entry === void 0 ? void 0 : entry.topic));
+                    if (entry && this.mqtt && !stillUsed) {
+                        this.mqtt.unsubscribe(entry.topic, (err) => {
+                            if (err) {
+                                this.report(err);
+                            }
+                        });
+                    }
+                }
+                // A filter that lost its last QoS-1 sub but still has QoS-0 subs must be
+                // re-SUBSCRIBEd at the lower QoS, or the broker keeps replaying to at-most-once subs.
+                for (const filter of maybeDowngrade) {
+                    const stillUsed = [...this.subscriptions.values()].some((s) => s.topic === filter);
+                    if (stillUsed && this.effectiveQos(filter) === 0) {
+                        (_a = this.mqtt) === null || _a === void 0 ? void 0 : _a.subscribe(filter, { qos: 0 }, (err) => {
+                            if (err) {
+                                this.report(err);
+                            }
+                        });
+                    }
+                }
+                if (this.subscriptions.size === 0) {
+                    this.close();
+                }
+            };
+            // If any topic's subscribe fails, roll this call's registrations back (and drop
+            // any now-unused broker filter) so a failed subscribe leaks no callback, then rethrow.
+            try {
+                yield Promise.all(acks);
+            }
+            catch (err) {
+                unsubscribe();
+                throw err;
+            }
+            const update = (next) => {
+                var _a;
+                const enabling = next.background === true;
+                const changedFilters = new Set();
+                // Remember the pre-update QoS per id so a rejected re-SUBSCRIBE can be rolled back.
+                const previous = new Map();
+                for (const id of ids) {
+                    const entry = this.subscriptions.get(id);
+                    if (!entry) {
+                        continue;
+                    }
+                    if (next.background !== undefined) {
+                        entry.background = next.background;
+                    }
+                    if (next.title !== undefined) {
+                        entry.title = next.title;
+                    }
+                    if (next.retry !== undefined) {
+                        const q = next.retry ? 1 : 0;
+                        if (q !== entry.qos) {
+                            previous.set(id, entry.qos);
+                            entry.qos = q;
+                            changedFilters.add(entry.topic);
+                        }
+                    }
+                }
+                if (enabling) {
+                    this.requestNotificationPermission();
+                }
+                // Re-SUBSCRIBE the affected filters at their new effective QoS (a SUBSCRIBE to an
+                // existing filter just updates its QoS — no unsubscribe gap). If the broker rejects
+                // it, the old subscription still stands, so restore the local QoS to match and
+                // surface the error rather than silently assuming the change took effect.
+                for (const filter of changedFilters) {
+                    (_a = this.mqtt) === null || _a === void 0 ? void 0 : _a.subscribe(filter, { qos: this.effectiveQos(filter) }, (err) => {
+                        if (!err) {
+                            return;
+                        }
+                        for (const [id, q] of previous) {
+                            const entry = this.subscriptions.get(id);
+                            if (entry && entry.topic === filter) {
+                                entry.qos = q;
+                            }
+                        }
+                        this.report(err);
+                    });
+                }
+            };
+            return { unsubscribe, update };
+        });
+    }
+    /** Tear down the connection and drop all active subscriptions. */
+    close() {
+        if (this.mqtt) {
+            this.mqtt.end(true);
+            this.mqtt = null;
+        }
+        this.connecting = null;
+        this.everConnected = false;
+        this.subscriptions.clear();
+    }
+    /**
+     * Re-register every active subscription. Called on each reconnect so a client that
+     * reconnects with a fresh (or cleared) session does not silently stop receiving;
+     * re-subscribing an existing filter is idempotent.
+     */
+    resubscribeAll() {
+        const client = this.mqtt;
+        if (!client) {
+            return;
+        }
+        const filters = new Set([...this.subscriptions.values()].map((s) => s.topic));
+        for (const filter of filters) {
+            client.subscribe(filter, { qos: this.effectiveQos(filter) }, (err) => {
+                if (err) {
+                    this.report(err);
+                }
+            });
+        }
+    }
+    // --- internals ---
+    connect() {
+        if (this.mqtt) {
+            return Promise.resolve(this.mqtt);
+        }
+        if (!this.connecting) {
+            this.connecting = this.open();
+            // A failed open must not poison future attempts — clear the cached
+            // in-flight promise so a later subscribe/publish can retry.
+            this.connecting.catch(() => {
+                this.connecting = null;
+            });
+        }
+        return this.connecting.then(() => this.mqtt);
+    }
+    endpointUrl() {
+        // The push endpoint set on the client (Client.setPushEndpoint) wins.
+        if (this.client.config.endpointPush !== '') {
+            return this.client.config.endpointPush;
+        }
+        // Otherwise default to a `push.` host on the regular API endpoint (not the
+        // independently-configurable realtime endpoint), scheme switched to ws/wss.
+        const wsEndpoint = this.client.config.endpoint
+            .replace('https://', 'wss://')
+            .replace('http://', 'ws://');
+        // Prefix the host with `push.` (scheme://host/path -> scheme://push.host/path).
+        const separator = '://';
+        const at = wsEndpoint.indexOf(separator);
+        return at === -1
+            ? wsEndpoint
+            : `${wsEndpoint.slice(0, at + separator.length)}push.${wsEndpoint.slice(at + separator.length)}`;
+    }
+    open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Read the credential set on the client (via Client.setJWT / setSession).
+            let authMethod;
+            let credential;
+            if (this.client.config.jwt) {
+                authMethod = 'appwrite-jwt';
+                credential = this.client.config.jwt;
+            }
+            else if (this.client.config.session) {
+                authMethod = 'appwrite-session';
+                credential = this.client.config.session;
+            }
+            else {
+                throw new Error('No credential set on the client; call Client.setJWT() or Client.setSession() first.');
+            }
+            const project = (_a = this.client.config.project) !== null && _a !== void 0 ? _a : '';
+            // Client id, when the app did not set one with Client.setPushClientId(). Unlike the
+            // native SDKs (which send an empty id and let the broker derive a stable one), mqtt.js
+            // rejects an empty id with clean start off, so derive a stable per-user id here from the
+            // credential this connection authenticates with: the JWT's userId, or the session's user
+            // id. A stable id keeps the broker's replay cursor resuming across reloads. The
+            // credential itself is never used as the id.
+            const clientId = this.client.config.pushClientId ||
+                (authMethod === 'appwrite-jwt'
+                    ? userIdFromJwt(credential)
+                    : userIdFromSession(credential)) ||
+                this.fallbackClientId;
+            const options = {
+                clientId,
+                protocolVersion: 5,
+                clean: false, // always keep the session so the broker can replay QoS-1 topics
+                keepalive: KEEP_ALIVE_SECONDS,
+                reconnectPeriod: RECONNECT_PERIOD_MS,
+                manualConnect: true,
+                // Enhanced auth carried in CONNECT properties.
+                properties: {
+                    authenticationMethod: authMethod,
+                    authenticationData: buffer.Buffer.from(credential),
+                    userProperties: { projectId: project },
+                },
+            };
+            const client = mqtt.connect(this.endpointUrl(), options);
+            this.mqtt = client;
+            client.on('message', (_topic, _payload, packet) => {
+                this.dispatch(packet).catch((err) => this.report(err));
+            });
+            // Persistent lifecycle listeners. Re-register every subscription on reconnect
+            // (harmless if the broker resumed our session), and surface the lifecycle to the
+            // caller's onOpen/onClose/onError hooks.
+            client.on('connect', () => {
+                var _a;
+                if (this.everConnected) {
+                    this.resubscribeAll();
+                }
+                this.everConnected = true;
+                (_a = this.onOpenCb) === null || _a === void 0 ? void 0 : _a.call(this);
+            });
+            client.on('close', () => { var _a; return (_a = this.onCloseCb) === null || _a === void 0 ? void 0 : _a.call(this); });
+            // The broker explains a refused CONNECT (CONNACK) or a server-initiated DISCONNECT
+            // with an MQTT 5 Reason String. mqtt.js reports only the reason code, so capture the
+            // string off the packet (packetreceive fires before mqtt.js handles it) and hand it
+            // to onError as the error message.
+            let refusedReason;
+            client.on('packetreceive', (packet) => {
+                var _a, _b;
+                if (packet.cmd === 'connack') {
+                    refusedReason =
+                        ((_a = packet.reasonCode) !== null && _a !== void 0 ? _a : 0) !== 0
+                            ? (_b = packet.properties) === null || _b === void 0 ? void 0 : _b.reasonString
+                            : undefined;
+                }
+            });
+            client.on('error', (err) => {
+                const error = this.connectError(err, refusedReason);
+                // While the first connect is pending its caller receives the error (and reports it
+                // through fail()); afterwards, e.g. on reconnect, report it here.
+                if (!this.opening) {
+                    this.report(error);
+                }
+            });
+            client.on('disconnect', (packet) => {
+                var _a, _b, _c;
+                if (((_a = packet.reasonCode) !== null && _a !== void 0 ? _a : 0) !== 0) {
+                    this.report(new Error((_c = (_b = packet.properties) === null || _b === void 0 ? void 0 : _b.reasonString) !== null && _c !== void 0 ? _c : `Disconnected by the broker (reason ${packet.reasonCode})`));
+                }
+            });
+            this.opening = true;
+            yield new Promise((resolve, reject) => {
+                const onConnect = (packet) => {
+                    var _a, _b;
+                    cleanup();
+                    const rc = (_b = (_a = packet.reasonCode) !== null && _a !== void 0 ? _a : packet.returnCode) !== null && _b !== void 0 ? _b : 0;
+                    if (rc !== 0) {
+                        this.close();
+                        reject(new Error(refusedReason !== null && refusedReason !== void 0 ? refusedReason : `MQTT authentication failed (CONNACK reason ${rc})`));
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                const onError = (err) => {
+                    cleanup();
+                    this.close();
+                    reject(this.connectError(err, refusedReason));
+                };
+                const cleanup = () => {
+                    this.opening = false;
+                    client.removeListener('connect', onConnect);
+                    client.removeListener('error', onError);
+                };
+                client.on('connect', onConnect);
+                client.on('error', onError);
+                client.connect();
+            });
+        });
+    }
+    /**
+     * The error for a failed connect: the broker's Reason String when it sent one (a refused
+     * CONNACK), else mqtt.js's error. Memoized so both error listeners hand out the same
+     * object and it is reported once.
+     */
+    connectError(err, reason) {
+        const source = toError(err);
+        let error = this.connectErrors.get(source);
+        if (!error) {
+            error = reason ? new Error(reason) : source;
+            this.connectErrors.set(source, error);
+        }
+        return error;
+    }
+    /** Fan a delivered packet out to every subscription whose filter matches. */
+    dispatch(packet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = buffer.Buffer.isBuffer(packet.payload)
+                ? packet.payload
+                : buffer.Buffer.from(packet.payload);
+            const message = {
+                topic: packet.topic.toString(),
+                data: new TextDecoder().decode(payload),
+                payload,
+                qos: packet.qos,
+            };
+            for (const sub of this.subscriptions.values()) {
+                if (matches(sub.topic, message.topic)) {
+                    yield sub.callback(message);
+                    // Notification is per-subscription: only subs that opted in post one,
+                    // each with its own title.
+                    if (sub.background) {
+                        this.notify(message, sub.title);
+                    }
+                }
+            }
+        });
+    }
+    requestNotificationPermission() {
+        if (typeof Notification !== 'undefined' &&
+            Notification.permission === 'default') {
+            Promise.resolve(Notification.requestPermission()).catch((err) => this.report(err));
+        }
+    }
+    /** Post a browser notification for a message a background subscription matched. */
+    notify(message, title) {
+        if (typeof Notification === 'undefined' ||
+            Notification.permission !== 'granted') {
+            return;
+        }
+        try {
+            new Notification(title !== null && title !== void 0 ? title : message.topic, {
+                body: message.data,
+            });
+        }
+        catch (_a) {
+            // Some browsers only allow notifications from a service worker; ignore.
+        }
+    }
+}
+/** Normalize anything thrown or passed to an error handler into an `Error`. */
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+/**
+ * The userId claim from an Appwrite JWT, used as the default MQTT client id so the
+ * broker's replay cursor is stable per user. Returns '' when the token is not a decodable JWT
+ * (e.g. a plain string), so the caller can fall back to the session or raw credential.
+ */
+function userIdFromJwt(jwt) {
+    if (!jwt) {
+        return '';
+    }
+    const parts = jwt.split('.');
+    if (parts.length < 2) {
+        return '';
+    }
+    try {
+        const json = buffer.Buffer.from(parts[1].replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf-8');
+        const payload = JSON.parse(json);
+        return typeof payload.userId === 'string' ? payload.userId : '';
+    }
+    catch (_a) {
+        return '';
+    }
+}
+/**
+ * The user id inside a session secret, which is base64 of JSON `{"id": <userId>, "secret": ...}`.
+ * Returns '' when the value is not such a secret.
+ */
+function userIdFromSession(session) {
+    if (!session) {
+        return '';
+    }
+    try {
+        const payload = JSON.parse(buffer.Buffer.from(session, 'base64').toString('utf-8'));
+        return typeof payload.id === 'string' ? payload.id : '';
+    }
+    catch (_a) {
+        return '';
+    }
+}
+/** A hex id, uuid4-like enough for a client-generated client id suffix. */
+function randomId() {
+    let out = '';
+    for (let i = 0; i < 32; i++) {
+        out += Math.floor(Math.random() * 16).toString(16);
+    }
+    return out;
+}
+/** MQTT topic-filter match with '+' (single level) and '#' (multi level). */
+function matches(filter, topic) {
+    const filterParts = filter.split('/');
+    const topicParts = topic.split('/');
+    for (let i = 0; i < filterParts.length; i++) {
+        const part = filterParts[i];
+        if (part === '#') {
+            return true;
+        }
+        if (i >= topicParts.length) {
+            return false;
+        }
+        if (part !== '+' && part !== topicParts[i]) {
+            return false;
+        }
+    }
+    return filterParts.length === topicParts.length;
+}
+
 /**
  * Helper class to generate permission strings for resources.
  */
@@ -45438,6 +46363,100 @@ class Role {
     }
 }
 
+/**
+ * Validate the levels passed to `path()`: a non-empty array of non-empty strings, none holding
+ * the level separator `/` or the wildcards `+` and `#` (use `any()` and `all()` for those).
+ */
+function levelsOf(levels) {
+    if (!Array.isArray(levels)) {
+        throw new Error("path() expects an array, e.g. path(['user'])");
+    }
+    if (levels.length === 0) {
+        throw new Error('path() needs at least one level');
+    }
+    return levels.map((level, index) => {
+        if (typeof level !== 'string') {
+            const type = level === null ? 'null' : typeof level;
+            throw new Error(`level at index ${index} must be a string, got ${type}`);
+        }
+        if (level === '') {
+            throw new Error(`empty level at index ${index}`);
+        }
+        if (level.includes('/')) {
+            const parts = level
+                .split('/')
+                .map((part) => `'${part}'`)
+                .join(', ');
+            throw new Error(`"${level}" contains "/", split it: path([${parts}])`);
+        }
+        if (level === '+') {
+            throw new Error('"+" is reserved, use any()');
+        }
+        if (level.includes('+')) {
+            throw new Error(`"${level}" contains "+", use any() for wildcards`);
+        }
+        if (level === '#') {
+            throw new Error('"#" is reserved, use all()');
+        }
+        if (level.includes('#')) {
+            throw new Error(`"${level}" contains "#", use all() for wildcards`);
+        }
+        return level;
+    });
+}
+/**
+ * Helper to build MQTT topics for `Push`, level by level.
+ *
+ *     Topic.path(['user', userId, 'notification']); // "user/123/notification"
+ *     Topic.path(['user']).any().path(['notification']); // "user/+/notification"
+ *     Topic.path(['org']).any().path(['logs']).all(); // "org/+/logs/#"
+ *
+ * `any()` matches exactly one level and `all()` everything below, at any depth (including the
+ * parent itself). `all()` ends the topic, so it returns a {@link ResolvedTopic}.
+ */
+class Topic {
+    constructor(levels) {
+        this.levels = levels;
+    }
+    /** Start a topic with the given levels, e.g. `Topic.path(['user', userId])`. */
+    static path(levels) {
+        return new Topic(levelsOf(levels));
+    }
+    /** Start a topic with a single-level wildcard (`+`). */
+    static any() {
+        return new Topic(['+']);
+    }
+    /** The multi-level wildcard alone (`#`): matches every topic. */
+    static all() {
+        return new ResolvedTopic(['#']);
+    }
+    /** Append the given levels. */
+    path(levels) {
+        return new Topic([...this.levels, ...levelsOf(levels)]);
+    }
+    /** Append a single-level wildcard (`+`): matches exactly one level. */
+    any() {
+        return new Topic([...this.levels, '+']);
+    }
+    /** Append the multi-level wildcard (`#`) and end the topic. */
+    all() {
+        return new ResolvedTopic([...this.levels, '#']);
+    }
+    toString() {
+        return this.levels.join('/');
+    }
+}
+/** A topic ended by `all()`: nothing can be appended after the `#` wildcard. */
+class ResolvedTopic {
+    /** @internal Created by {@link Topic.all}. */
+    constructor(levels) {
+        this.levels = levels;
+    }
+    toString() {
+        return this.levels.join('/');
+    }
+}
+
 function normalize(id) {
     if (id === undefined || id === null) {
         throw new Error('Channel ID is required');
@@ -46668,7 +47687,7 @@ exports.QuerySuggestionResource = void 0;
     QuerySuggestionResource["Buckets"] = "buckets";
     QuerySuggestionResource["Providers"] = "providers";
     QuerySuggestionResource["Messages"] = "messages";
-    QuerySuggestionResource["AppwritePushLedger"] = "appwritepushledger";
+    QuerySuggestionResource["PushLedger"] = "pushledger";
     QuerySuggestionResource["Topics"] = "topics";
     QuerySuggestionResource["Subscribers"] = "subscribers";
     QuerySuggestionResource["Targets"] = "targets";
@@ -46735,6 +47754,7 @@ exports.ProjectEmailTemplateId = void 0;
     ProjectEmailTemplateId["SessionAlert"] = "sessionAlert";
     ProjectEmailTemplateId["OtpSession"] = "otpSession";
     ProjectEmailTemplateId["OtpVerification"] = "otpVerification";
+    ProjectEmailTemplateId["OtpRecovery"] = "otpRecovery";
 })(exports.ProjectEmailTemplateId || (exports.ProjectEmailTemplateId = {}));
 
 exports.ProjectEmailTemplateLocale = void 0;
@@ -46962,6 +47982,9 @@ exports.Runtime = void 0;
     Runtime["Pythonml311"] = "python-ml-3.11";
     Runtime["Pythonml312"] = "python-ml-3.12";
     Runtime["Pythonml313"] = "python-ml-3.13";
+    Runtime["Deno121"] = "deno-1.21";
+    Runtime["Deno124"] = "deno-1.24";
+    Runtime["Deno135"] = "deno-1.35";
     Runtime["Deno140"] = "deno-1.40";
     Runtime["Deno146"] = "deno-1.46";
     Runtime["Deno20"] = "deno-2.0";
@@ -47195,6 +48218,17 @@ exports.ExecutionMethod = void 0;
     ExecutionMethod["HEAD"] = "HEAD";
 })(exports.ExecutionMethod || (exports.ExecutionMethod = {}));
 
+exports.ConversationType = void 0;
+(function (ConversationType) {
+    ConversationType["Support"] = "support";
+    ConversationType["Feedback"] = "feedback";
+    ConversationType["Docs"] = "docs";
+    ConversationType["Enterprise"] = "enterprise";
+    ConversationType["Startup"] = "startup";
+    ConversationType["Partner"] = "partner";
+    ConversationType["Sponsorship"] = "sponsorship";
+})(exports.ConversationType || (exports.ConversationType = {}));
+
 exports.BlockResourceType = void 0;
 (function (BlockResourceType) {
     BlockResourceType["Projects"] = "projects";
@@ -47391,6 +48425,24 @@ exports.ProjectAuthMethodId = void 0;
     ProjectAuthMethodId["Phone"] = "phone";
 })(exports.ProjectAuthMethodId || (exports.ProjectAuthMethodId = {}));
 
+exports.ProjectOAuth2Auth0Prompt = void 0;
+(function (ProjectOAuth2Auth0Prompt) {
+    ProjectOAuth2Auth0Prompt["None"] = "none";
+    ProjectOAuth2Auth0Prompt["Login"] = "login";
+    ProjectOAuth2Auth0Prompt["Consent"] = "consent";
+})(exports.ProjectOAuth2Auth0Prompt || (exports.ProjectOAuth2Auth0Prompt = {}));
+
+exports.ProjectOAuth2DiscordPrompt = void 0;
+(function (ProjectOAuth2DiscordPrompt) {
+    ProjectOAuth2DiscordPrompt["None"] = "none";
+    ProjectOAuth2DiscordPrompt["Consent"] = "consent";
+})(exports.ProjectOAuth2DiscordPrompt || (exports.ProjectOAuth2DiscordPrompt = {}));
+
+exports.ProjectOAuth2GitHubPrompt = void 0;
+(function (ProjectOAuth2GitHubPrompt) {
+    ProjectOAuth2GitHubPrompt["SelectAccount"] = "select_account";
+})(exports.ProjectOAuth2GitHubPrompt || (exports.ProjectOAuth2GitHubPrompt = {}));
+
 exports.ProjectOAuth2GooglePrompt = void 0;
 (function (ProjectOAuth2GooglePrompt) {
     ProjectOAuth2GooglePrompt["None"] = "none";
@@ -47398,6 +48450,22 @@ exports.ProjectOAuth2GooglePrompt = void 0;
     ProjectOAuth2GooglePrompt["SelectAccount"] = "select_account";
 })(exports.ProjectOAuth2GooglePrompt || (exports.ProjectOAuth2GooglePrompt = {}));
 
+exports.ProjectOAuth2KakaoPrompt = void 0;
+(function (ProjectOAuth2KakaoPrompt) {
+    ProjectOAuth2KakaoPrompt["None"] = "none";
+    ProjectOAuth2KakaoPrompt["Login"] = "login";
+    ProjectOAuth2KakaoPrompt["Create"] = "create";
+    ProjectOAuth2KakaoPrompt["SelectAccount"] = "select_account";
+})(exports.ProjectOAuth2KakaoPrompt || (exports.ProjectOAuth2KakaoPrompt = {}));
+
+exports.ProjectOAuth2MicrosoftPrompt = void 0;
+(function (ProjectOAuth2MicrosoftPrompt) {
+    ProjectOAuth2MicrosoftPrompt["None"] = "none";
+    ProjectOAuth2MicrosoftPrompt["Login"] = "login";
+    ProjectOAuth2MicrosoftPrompt["Consent"] = "consent";
+    ProjectOAuth2MicrosoftPrompt["SelectAccount"] = "select_account";
+})(exports.ProjectOAuth2MicrosoftPrompt || (exports.ProjectOAuth2MicrosoftPrompt = {}));
+
 exports.ProjectOAuth2OidcPrompt = void 0;
 (function (ProjectOAuth2OidcPrompt) {
     ProjectOAuth2OidcPrompt["None"] = "none";
@@ -47406,6 +48474,24 @@ exports.ProjectOAuth2OidcPrompt = void 0;
     ProjectOAuth2OidcPrompt["SelectAccount"] = "select_account";
 })(exports.ProjectOAuth2OidcPrompt || (exports.ProjectOAuth2OidcPrompt = {}));
 
+exports.ProjectOAuth2OktaPrompt = void 0;
+(function (ProjectOAuth2OktaPrompt) {
+    ProjectOAuth2OktaPrompt["None"] = "none";
+    ProjectOAuth2OktaPrompt["Login"] = "login";
+    ProjectOAuth2OktaPrompt["Consent"] = "consent";
+})(exports.ProjectOAuth2OktaPrompt || (exports.ProjectOAuth2OktaPrompt = {}));
+
+exports.ProjectOAuth2SalesforcePrompt = void 0;
+(function (ProjectOAuth2SalesforcePrompt) {
+    ProjectOAuth2SalesforcePrompt["Login"] = "login";
+    ProjectOAuth2SalesforcePrompt["Consent"] = "consent";
+})(exports.ProjectOAuth2SalesforcePrompt || (exports.ProjectOAuth2SalesforcePrompt = {}));
+
+exports.ProjectOAuth2ZohoPrompt = void 0;
+(function (ProjectOAuth2ZohoPrompt) {
+    ProjectOAuth2ZohoPrompt["Consent"] = "consent";
+})(exports.ProjectOAuth2ZohoPrompt || (exports.ProjectOAuth2ZohoPrompt = {}));
+
 exports.ProjectOAuthProviderId = void 0;
 (function (ProjectOAuthProviderId) {
     ProjectOAuthProviderId["Amazon"] = "amazon";
@@ -47603,6 +48689,9 @@ exports.BuildRuntime = void 0;
     BuildRuntime["Pythonml311"] = "python-ml-3.11";
     BuildRuntime["Pythonml312"] = "python-ml-3.12";
     BuildRuntime["Pythonml313"] = "python-ml-3.13";
+    BuildRuntime["Deno121"] = "deno-1.21";
+    BuildRuntime["Deno124"] = "deno-1.24";
+    BuildRuntime["Deno135"] = "deno-1.35";
     BuildRuntime["Deno140"] = "deno-1.40";
     BuildRuntime["Deno146"] = "deno-1.46";
     BuildRuntime["Deno20"] = "deno-2.0";
@@ -48020,6 +49109,17 @@ exports.ExecutionStatus = void 0;
     ExecutionStatus["Scheduled"] = "scheduled";
 })(exports.ExecutionStatus || (exports.ExecutionStatus = {}));
 
+exports.OAuth2GithubPrompt = void 0;
+(function (OAuth2GithubPrompt) {
+    OAuth2GithubPrompt["SelectAccount"] = "select_account";
+})(exports.OAuth2GithubPrompt || (exports.OAuth2GithubPrompt = {}));
+
+exports.OAuth2DiscordPrompt = void 0;
+(function (OAuth2DiscordPrompt) {
+    OAuth2DiscordPrompt["None"] = "none";
+    OAuth2DiscordPrompt["Consent"] = "consent";
+})(exports.OAuth2DiscordPrompt || (exports.OAuth2DiscordPrompt = {}));
+
 exports.OAuth2GooglePrompt = void 0;
 (function (OAuth2GooglePrompt) {
     OAuth2GooglePrompt["None"] = "none";
@@ -48027,6 +49127,24 @@ exports.OAuth2GooglePrompt = void 0;
     OAuth2GooglePrompt["SelectAccount"] = "select_account";
 })(exports.OAuth2GooglePrompt || (exports.OAuth2GooglePrompt = {}));
 
+exports.OAuth2ZohoPrompt = void 0;
+(function (OAuth2ZohoPrompt) {
+    OAuth2ZohoPrompt["Consent"] = "consent";
+})(exports.OAuth2ZohoPrompt || (exports.OAuth2ZohoPrompt = {}));
+
+exports.OAuth2SalesforcePrompt = void 0;
+(function (OAuth2SalesforcePrompt) {
+    OAuth2SalesforcePrompt["Login"] = "login";
+    OAuth2SalesforcePrompt["Consent"] = "consent";
+})(exports.OAuth2SalesforcePrompt || (exports.OAuth2SalesforcePrompt = {}));
+
+exports.OAuth2Auth0Prompt = void 0;
+(function (OAuth2Auth0Prompt) {
+    OAuth2Auth0Prompt["None"] = "none";
+    OAuth2Auth0Prompt["Login"] = "login";
+    OAuth2Auth0Prompt["Consent"] = "consent";
+})(exports.OAuth2Auth0Prompt || (exports.OAuth2Auth0Prompt = {}));
+
 exports.OAuth2OidcPrompt = void 0;
 (function (OAuth2OidcPrompt) {
     OAuth2OidcPrompt["None"] = "none";
@@ -48035,6 +49153,29 @@ exports.OAuth2OidcPrompt = void 0;
     OAuth2OidcPrompt["SelectAccount"] = "select_account";
 })(exports.OAuth2OidcPrompt || (exports.OAuth2OidcPrompt = {}));
 
+exports.OAuth2OktaPrompt = void 0;
+(function (OAuth2OktaPrompt) {
+    OAuth2OktaPrompt["None"] = "none";
+    OAuth2OktaPrompt["Login"] = "login";
+    OAuth2OktaPrompt["Consent"] = "consent";
+})(exports.OAuth2OktaPrompt || (exports.OAuth2OktaPrompt = {}));
+
+exports.OAuth2MicrosoftPrompt = void 0;
+(function (OAuth2MicrosoftPrompt) {
+    OAuth2MicrosoftPrompt["None"] = "none";
+    OAuth2MicrosoftPrompt["Login"] = "login";
+    OAuth2MicrosoftPrompt["Consent"] = "consent";
+    OAuth2MicrosoftPrompt["SelectAccount"] = "select_account";
+})(exports.OAuth2MicrosoftPrompt || (exports.OAuth2MicrosoftPrompt = {}));
+
+exports.OAuth2KakaoPrompt = void 0;
+(function (OAuth2KakaoPrompt) {
+    OAuth2KakaoPrompt["None"] = "none";
+    OAuth2KakaoPrompt["Login"] = "login";
+    OAuth2KakaoPrompt["Create"] = "create";
+    OAuth2KakaoPrompt["SelectAccount"] = "select_account";
+})(exports.OAuth2KakaoPrompt || (exports.OAuth2KakaoPrompt = {}));
+
 exports.PlatformType = void 0;
 (function (PlatformType) {
     PlatformType["Windows"] = "windows";
@@ -48121,6 +49262,7 @@ exports.Domains = Domains;
 exports.Embeddings = Embeddings;
 exports.Functions = Functions;
 exports.Graphql = Graphql;
+exports.Growth = Growth;
 exports.ID = ID;
 exports.Locale = Locale;
 exports.Manager = Manager;
@@ -48139,14 +49281,17 @@ exports.Presences = Presences;
 exports.Project = Project;
 exports.Projects = Projects;
 exports.Proxy = Proxy;
+exports.Push = Push;
 exports.Query = Query;
 exports.Realtime = Realtime;
+exports.ResolvedTopic = ResolvedTopic;
 exports.Role = Role;
 exports.Sites = Sites;
 exports.Storage = Storage;
 exports.TablesDB = TablesDB;
 exports.Teams = Teams;
 exports.Tokens = Tokens;
+exports.Topic = Topic;
 exports.Usage = Usage;
 exports.Users = Users;
 exports.Vcs = Vcs;