@appwrite.io/console 18.2.0 → 18.3.0-rc.1

package/dist/iife/sdk.js

@@ -4467,7 +4467,7 @@
                 'x-sdk-name': 'Console',
                 'x-sdk-platform': 'console',
                 'x-sdk-language': 'web',
-                'x-sdk-version': '18.2.0',
+                'x-sdk-version': '18.3.0-rc.1',
                 'X-Appwrite-Response-Format': '2.3.0',
             };
             this.realtime = {
@@ -5320,29 +5320,6 @@
     }
     Client.CHUNK_SIZE = 1024 * 1024 * 5;
 
-    class Service {
-        constructor(client) {
-            this.client = client;
-        }
-        static flatten(data, prefix = '') {
-            let output = {};
-            for (const [key, value] of Object.entries(data)) {
-                const finalKey = prefix ? prefix + '[' + key + ']' : key;
-                if (Array.isArray(value)) {
-                    output = Object.assign(Object.assign({}, output), Service.flatten(value, finalKey));
-                }
-                else {
-                    output[finalKey] = value;
-                }
-            }
-            return output;
-        }
-    }
-    /**
-     * The size for chunked uploads in bytes.
-     */
-    Service.CHUNK_SIZE = 5 * 1024 * 1024; // 5MB
-
     class Account {
         constructor(client) {
             this.client = client;
@@ -7404,7 +7381,7 @@
             }
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             if (typeof window !== 'undefined' && (window === null || window === void 0 ? void 0 : window.location)) {
@@ -7813,7 +7790,7 @@
             }
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             if (typeof window !== 'undefined' && (window === null || window === void 0 ? void 0 : window.location)) {
@@ -8381,6 +8358,369 @@
         }
     }
 
+    class Analytics {
+        constructor(client) {
+            this.client = client;
+        }
+        listProperties(paramsOrFirst, ...rest) {
+            let params;
+            if ((typeof paramsOrFirst === 'undefined' && rest.length === 0) ||
+                (paramsOrFirst &&
+                    typeof paramsOrFirst === 'object' &&
+                    !Array.isArray(paramsOrFirst))) {
+                params = (paramsOrFirst || {});
+            }
+            else {
+                params = {
+                    queries: paramsOrFirst,
+                    search: rest[0],
+                    total: rest[1],
+                };
+            }
+            const queries = params.queries;
+            const search = params.search;
+            const total = params.total;
+            const apiPath = '/analytics/properties';
+            const apiPayload = {};
+            if (typeof queries !== 'undefined') {
+                apiPayload['queries'] = queries;
+            }
+            if (typeof search !== 'undefined') {
+                apiPayload['search'] = search;
+            }
+            if (typeof total !== 'undefined') {
+                apiPayload['total'] = total;
+            }
+            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, apiPayload);
+        }
+        createProperty(paramsOrFirst, ...rest) {
+            let params;
+            if (paramsOrFirst &&
+                typeof paramsOrFirst === 'object' &&
+                !Array.isArray(paramsOrFirst)) {
+                params = (paramsOrFirst || {});
+            }
+            else {
+                params = {
+                    propertyId: paramsOrFirst,
+                    name: rest[0],
+                    domain: rest[1],
+                    timezone: rest[2],
+                    enabled: rest[3],
+                    xpublic: rest[4],
+                    allowedOrigins: rest[5],
+                };
+            }
+            const propertyId = params.propertyId;
+            const name = params.name;
+            const domain = params.domain;
+            const timezone = params.timezone;
+            const enabled = params.enabled;
+            const xpublic = params.xpublic;
+            const allowedOrigins = params.allowedOrigins;
+            if (typeof propertyId === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "propertyId"');
+            }
+            if (typeof name === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "name"');
+            }
+            const apiPath = '/analytics/properties';
+            const apiPayload = {};
+            if (typeof propertyId !== 'undefined') {
+                apiPayload['propertyId'] = propertyId;
+            }
+            if (typeof name !== 'undefined') {
+                apiPayload['name'] = name;
+            }
+            if (typeof domain !== 'undefined') {
+                apiPayload['domain'] = domain;
+            }
+            if (typeof timezone !== 'undefined') {
+                apiPayload['timezone'] = timezone;
+            }
+            if (typeof enabled !== 'undefined') {
+                apiPayload['enabled'] = enabled;
+            }
+            if (typeof xpublic !== 'undefined') {
+                apiPayload['public'] = xpublic;
+            }
+            if (typeof allowedOrigins !== 'undefined') {
+                apiPayload['allowedOrigins'] = allowedOrigins;
+            }
+            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, apiPayload);
+        }
+        getProperty(paramsOrFirst) {
+            let params;
+            if (paramsOrFirst &&
+                typeof paramsOrFirst === 'object' &&
+                !Array.isArray(paramsOrFirst)) {
+                params = (paramsOrFirst || {});
+            }
+            else {
+                params = {
+                    propertyId: paramsOrFirst,
+                };
+            }
+            const propertyId = params.propertyId;
+            if (typeof propertyId === 'undefined' || propertyId === '') {
+                throw new AppwriteException('Missing required parameter: "propertyId"');
+            }
+            const apiPath = '/analytics/properties/{propertyId}'.replace('{propertyId}', encodeURIComponent(String(propertyId)));
+            const apiPayload = {};
+            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, apiPayload);
+        }
+        updateProperty(paramsOrFirst, ...rest) {
+            let params;
+            if (paramsOrFirst &&
+                typeof paramsOrFirst === 'object' &&
+                !Array.isArray(paramsOrFirst)) {
+                params = (paramsOrFirst || {});
+            }
+            else {
+                params = {
+                    propertyId: paramsOrFirst,
+                    name: rest[0],
+                    domain: rest[1],
+                    timezone: rest[2],
+                    enabled: rest[3],
+                    xpublic: rest[4],
+                    allowedOrigins: rest[5],
+                };
+            }
+            const propertyId = params.propertyId;
+            const name = params.name;
+            const domain = params.domain;
+            const timezone = params.timezone;
+            const enabled = params.enabled;
+            const xpublic = params.xpublic;
+            const allowedOrigins = params.allowedOrigins;
+            if (typeof propertyId === 'undefined' || propertyId === '') {
+                throw new AppwriteException('Missing required parameter: "propertyId"');
+            }
+            const apiPath = '/analytics/properties/{propertyId}'.replace('{propertyId}', encodeURIComponent(String(propertyId)));
+            const apiPayload = {};
+            if (typeof name !== 'undefined') {
+                apiPayload['name'] = name;
+            }
+            if (typeof domain !== 'undefined') {
+                apiPayload['domain'] = domain;
+            }
+            if (typeof timezone !== 'undefined') {
+                apiPayload['timezone'] = timezone;
+            }
+            if (typeof enabled !== 'undefined') {
+                apiPayload['enabled'] = enabled;
+            }
+            if (typeof xpublic !== 'undefined') {
+                apiPayload['public'] = xpublic;
+            }
+            if (typeof allowedOrigins !== 'undefined') {
+                apiPayload['allowedOrigins'] = allowedOrigins;
+            }
+            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, apiPayload);
+        }
+        deleteProperty(paramsOrFirst) {
+            let params;
+            if (paramsOrFirst &&
+                typeof paramsOrFirst === 'object' &&
+                !Array.isArray(paramsOrFirst)) {
+                params = (paramsOrFirst || {});
+            }
+            else {
+                params = {
+                    propertyId: paramsOrFirst,
+                };
+            }
+            const propertyId = params.propertyId;
+            if (typeof propertyId === 'undefined' || propertyId === '') {
+                throw new AppwriteException('Missing required parameter: "propertyId"');
+            }
+            const apiPath = '/analytics/properties/{propertyId}'.replace('{propertyId}', encodeURIComponent(String(propertyId)));
+            const apiPayload = {};
+            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('delete', uri, apiHeaders, apiPayload);
+        }
+        createEvent(paramsOrFirst, ...rest) {
+            let params;
+            if (paramsOrFirst &&
+                typeof paramsOrFirst === 'object' &&
+                !Array.isArray(paramsOrFirst)) {
+                params = (paramsOrFirst || {});
+            }
+            else {
+                params = {
+                    propertyId: paramsOrFirst,
+                    name: rest[0],
+                    url: rest[1],
+                    domain: rest[2],
+                    referrer: rest[3],
+                    screenWidth: rest[4],
+                    sessionHash: rest[5],
+                    scrollDepth: rest[6],
+                    engagementTime: rest[7],
+                    props: rest[8],
+                    userId: rest[9],
+                    ip: rest[10],
+                    userAgent: rest[11],
+                };
+            }
+            const propertyId = params.propertyId;
+            const name = params.name;
+            const url = params.url;
+            const domain = params.domain;
+            const referrer = params.referrer;
+            const screenWidth = params.screenWidth;
+            const sessionHash = params.sessionHash;
+            const scrollDepth = params.scrollDepth;
+            const engagementTime = params.engagementTime;
+            const props = params.props;
+            const userId = params.userId;
+            const ip = params.ip;
+            const userAgent = params.userAgent;
+            if (typeof propertyId === 'undefined' || propertyId === '') {
+                throw new AppwriteException('Missing required parameter: "propertyId"');
+            }
+            if (typeof name === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "name"');
+            }
+            if (typeof url === 'undefined') {
+                throw new AppwriteException('Missing required parameter: "url"');
+            }
+            const apiPath = '/analytics/properties/{propertyId}/events'.replace('{propertyId}', encodeURIComponent(String(propertyId)));
+            const apiPayload = {};
+            if (typeof name !== 'undefined') {
+                apiPayload['name'] = name;
+            }
+            if (typeof url !== 'undefined') {
+                apiPayload['url'] = url;
+            }
+            if (typeof domain !== 'undefined') {
+                apiPayload['domain'] = domain;
+            }
+            if (typeof referrer !== 'undefined') {
+                apiPayload['referrer'] = referrer;
+            }
+            if (typeof screenWidth !== 'undefined') {
+                apiPayload['screenWidth'] = screenWidth;
+            }
+            if (typeof sessionHash !== 'undefined') {
+                apiPayload['sessionHash'] = sessionHash;
+            }
+            if (typeof scrollDepth !== 'undefined') {
+                apiPayload['scrollDepth'] = scrollDepth;
+            }
+            if (typeof engagementTime !== 'undefined') {
+                apiPayload['engagementTime'] = engagementTime;
+            }
+            if (typeof props !== 'undefined') {
+                apiPayload['props'] = props;
+            }
+            if (typeof userId !== 'undefined') {
+                apiPayload['userId'] = userId;
+            }
+            if (typeof ip !== 'undefined') {
+                apiPayload['ip'] = ip;
+            }
+            if (typeof userAgent !== 'undefined') {
+                apiPayload['userAgent'] = userAgent;
+            }
+            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, apiPayload);
+        }
+        listMetrics(paramsOrFirst, ...rest) {
+            let params;
+            if (paramsOrFirst &&
+                typeof paramsOrFirst === 'object' &&
+                !Array.isArray(paramsOrFirst)) {
+                params = (paramsOrFirst || {});
+            }
+            else {
+                params = {
+                    propertyId: paramsOrFirst,
+                    queries: rest[0],
+                    interval: rest[1],
+                    dimensions: rest[2],
+                    dateRange: rest[3],
+                    startAt: rest[4],
+                    endAt: rest[5],
+                    limit: rest[6],
+                };
+            }
+            const propertyId = params.propertyId;
+            const queries = params.queries;
+            const interval = params.interval;
+            const dimensions = params.dimensions;
+            const dateRange = params.dateRange;
+            const startAt = params.startAt;
+            const endAt = params.endAt;
+            const limit = params.limit;
+            if (typeof propertyId === 'undefined' || propertyId === '') {
+                throw new AppwriteException('Missing required parameter: "propertyId"');
+            }
+            const apiPath = '/analytics/properties/{propertyId}/metrics'.replace('{propertyId}', encodeURIComponent(String(propertyId)));
+            const apiPayload = {};
+            if (typeof queries !== 'undefined') {
+                apiPayload['queries'] = queries;
+            }
+            if (typeof interval !== 'undefined') {
+                apiPayload['interval'] = interval;
+            }
+            if (typeof dimensions !== 'undefined') {
+                apiPayload['dimensions'] = dimensions;
+            }
+            if (typeof dateRange !== 'undefined') {
+                apiPayload['dateRange'] = dateRange;
+            }
+            if (typeof startAt !== 'undefined') {
+                apiPayload['startAt'] = startAt;
+            }
+            if (typeof endAt !== 'undefined') {
+                apiPayload['endAt'] = endAt;
+            }
+            if (typeof limit !== 'undefined') {
+                apiPayload['limit'] = limit;
+            }
+            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, apiPayload);
+        }
+    }
+
     class Apps {
         constructor(client) {
             this.client = client;
@@ -9273,7 +9613,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9318,7 +9658,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9347,7 +9687,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9392,7 +9732,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9431,7 +9771,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9473,7 +9813,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9535,7 +9875,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9629,7 +9969,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -9753,7 +10093,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -19329,7 +19669,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -29968,7 +30308,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -30075,7 +30415,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -38259,7 +38599,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -39090,7 +39430,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -39183,7 +39523,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -39221,7 +39561,7 @@
             const uri = new URL(this.client.config.endpoint + apiPath);
             apiPayload['project'] = this.client.config.project;
             apiPayload['impersonateuserid'] = this.client.config.impersonateuserid;
-            for (const [key, value] of Object.entries(Service.flatten(apiPayload))) {
+            for (const [key, value] of Object.entries(Client.flatten(apiPayload))) {
                 uri.searchParams.append(key, value);
             }
             return uri.toString();
@@ -49800,9 +50140,8 @@
      *     );
      *     // sub.update({ background: true }); sub.unsubscribe();
      */
-    class Push extends Service {
+    class Push {
         constructor(client) {
-            super(client);
             this.mqtt = null;
             this.connecting = null;
             this.Buffer = null;
@@ -49832,6 +50171,7 @@
             this.connectedKey = '';
             this.connectionEpoch = 0;
             this.subscriptions = new Map();
+            this.client = client;
         }
         // 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.
@@ -50571,6 +50911,670 @@
         return filterParts.length === topicParts.length;
     }
 
+    /**
+     * Analytics auto-tracking helpers.
+     *
+     * These are hand-written companions to the generated `Analytics` service.
+     * The generated service exposes `createEvent(params)` for arbitrary events;
+     * this module wires up common auto-tracking behaviours (pageviews, outbound
+     * links, downloads, scroll depth, active engagement) on top of it.
+     *
+     * The tracking helpers accept a plain event-emitter function so they do not
+     * hard-couple to the generated `Analytics` class. The emitter adapts this
+     * module's option shape to `createEvent`: `url` is required there, and `props`
+     * is a flat alternating key/value list rather than an object.
+     *
+     * ```ts
+     * const analytics = new Analytics(client);
+     * const tracking = new AnalyticsTracking(
+     *     (name, options) => analytics.createEvent({
+     *         propertyId: options?.propertyId ?? '<PROPERTY_ID>',
+     *         name,
+     *         url: options?.url ?? window.location.href,
+     *         referrer: options?.referrer,
+     *         scrollDepth: options?.scrollDepth,
+     *         engagementTime: options?.engagementTime,
+     *         props: Object.entries(options?.props ?? {}).flatMap(
+     *             ([key, value]) => [key, String(value)],
+     *         ),
+     *     }),
+     *     { propertyId: '<PROPERTY_ID>' }
+     * );
+     * tracking.enableAllAutoTracking();
+     * ```
+     *
+     * `propertyId` is optional: when set it is merged into the options of every
+     * emitted event, so an emitter that forwards `options.propertyId` (as above)
+     * picks it up instead of every caller hand-rolling it into the closure.
+     * Per-event `propertyId` always wins over the configured default.
+     *
+     * All helpers respect `navigator.doNotTrack === '1'` by default; opt out with
+     * `respectDoNotTrack: false` in the constructor options.
+     *
+     * Engagement time follows Plausible's model: rather than one total at unload,
+     * a delta is emitted at every natural checkpoint of the visit (tab hidden, SPA
+     * route change, unload). See `enableAutoEngagementTime` for details.
+     *
+     * Auto-emitted event names follow `snake_case` + lowercase (`pageview`,
+     * `outbound_link`, `file_download`, `screen_view`, etc.). Any prop keys use
+     * camelCase to match the endpoint's parameter naming. Callers can pass any
+     * custom event name; the auto-track methods only own the events they emit
+     * themselves.
+     */
+    const DEFAULT_DOWNLOAD_EXTENSIONS = [
+        'pdf',
+        'zip',
+        'rar',
+        '7z',
+        'tar',
+        'gz',
+        'csv',
+        'tsv',
+        'xls',
+        'xlsx',
+        'doc',
+        'docx',
+        'ppt',
+        'pptx',
+        'dmg',
+        'exe',
+        'msi',
+        'pkg',
+        'deb',
+        'rpm',
+        'apk',
+        'mp3',
+        'wav',
+        'flac',
+        'mp4',
+        'mov',
+        'avi',
+        'mkv',
+        'webm',
+    ];
+    /**
+     * Two-part public suffixes common enough to matter for outbound-link detection.
+     * See `rootDomain()` for why this is a short list rather than the Public Suffix
+     * List.
+     */
+    const MULTI_PART_SUFFIXES = new Set([
+        'co.uk',
+        'org.uk',
+        'ac.uk',
+        'gov.uk',
+        'me.uk',
+        'net.uk',
+        'sch.uk',
+        'co.jp',
+        'ne.jp',
+        'or.jp',
+        'ac.jp',
+        'go.jp',
+        'com.au',
+        'net.au',
+        'org.au',
+        'edu.au',
+        'gov.au',
+        'com.br',
+        'net.br',
+        'org.br',
+        'com.cn',
+        'net.cn',
+        'org.cn',
+        'gov.cn',
+        'co.in',
+        'net.in',
+        'org.in',
+        'co.nz',
+        'net.nz',
+        'org.nz',
+        'co.za',
+        'org.za',
+        'com.mx',
+        'com.ar',
+        'com.co',
+        'com.pe',
+        'com.tr',
+        'com.tw',
+        'com.sg',
+        'com.hk',
+        'com.my',
+        'com.ph',
+        'com.vn',
+        'co.kr',
+        'co.il',
+        'co.id',
+        'co.th',
+        'com.ua',
+        'com.pl',
+        'com.es',
+    ]);
+    const SCROLL_DEPTH_THROTTLE_MS = 200;
+    class AnalyticsTracking {
+        constructor(emit, options = {}) {
+            this.pageviewCleanups = [];
+            this.scrollCleanups = [];
+            this.engagementCleanups = [];
+            this.maxScrollDepth = 0;
+            this.scrollTicking = false;
+            this.lastScrollReport = 0;
+            this.engagementStart = 0;
+            this.engagementAccumulatedMs = 0;
+            this.engagementActive = false;
+            this.emit = emit;
+            this.respectDoNotTrack = options.respectDoNotTrack !== false;
+            this.propertyId = options.propertyId;
+        }
+        /**
+         * Enable the opinionated default auto-tracking set: pageviews, outbound
+         * links, scroll depth and active engagement time. Downloads must be opted
+         * into separately via `enableAutoDownloadTracking()` because the extension
+         * list is application-specific.
+         */
+        enableAllAutoTracking() {
+            this.enableAutoPageviews();
+            this.enableAutoOutboundTracking();
+            this.enableAutoScrollDepth();
+            this.enableAutoEngagementTime();
+        }
+        /**
+         * Track an event manually. Respects the DNT setting and swallows emitter
+         * exceptions so tracking failures never surface to the host page.
+         */
+        track(name, options) {
+            if (!this.canTrack()) {
+                return;
+            }
+            try {
+                this.emit(name, this.withPropertyId(options));
+            }
+            catch (error) {
+                console.warn('AnalyticsTracking: emitter threw', error);
+            }
+        }
+        /**
+         * Convenience wrapper for pageview-shaped events.
+         */
+        pageview(url, referrer) {
+            this.track('pageview', {
+                url: url !== null && url !== void 0 ? url : this.currentPageUrl(),
+                referrer: referrer !== null && referrer !== void 0 ? referrer : (typeof document !== 'undefined'
+                    ? document.referrer
+                    : undefined),
+            });
+        }
+        /**
+         * Enable SPA-aware pageview tracking. Fires an initial pageview on
+         * enable, then again on every `pushState`, `replaceState`, `popstate`
+         * or hashchange. Idempotent — repeat calls no-op.
+         */
+        enableAutoPageviews() {
+            if (this.pageviewCleanups.length > 0) {
+                return;
+            }
+            if (typeof window === 'undefined' || typeof history === 'undefined') {
+                return;
+            }
+            this.currentPath = this.currentPageUrl();
+            this.pageview();
+            const handleNavigation = () => {
+                const nextPath = this.currentPageUrl();
+                if (nextPath === this.currentPath) {
+                    return;
+                }
+                const previous = this.currentPath;
+                this.currentPath = nextPath;
+                this.flushScrollDepth(previous);
+                this.flushEngagement(previous);
+                this.pageview(nextPath);
+                // flushEngagement no longer auto-restarts the timer (see its
+                // implementation note re: bfcache). SPA navigation stays on the
+                // same document, so restart engagement tracking for the new
+                // route as long as the tab is visible.
+                if (this.engagementCleanups.length > 0 &&
+                    (typeof document === 'undefined' ||
+                        document.visibilityState !== 'hidden')) {
+                    this.startEngagement();
+                }
+            };
+            const originalPushState = history.pushState.bind(history);
+            const originalReplaceState = history.replaceState.bind(history);
+            // Our wrappers stay reachable after cleanup whenever another library
+            // patched on top of ours, so they have to be switchable off rather than
+            // merely unreferenced.
+            let patchActive = true;
+            const patchedPushState = (data, unused, url) => {
+                originalPushState(data, unused, url);
+                if (patchActive) {
+                    handleNavigation();
+                }
+            };
+            const patchedReplaceState = (data, unused, url) => {
+                originalReplaceState(data, unused, url);
+                if (patchActive) {
+                    handleNavigation();
+                }
+            };
+            history.pushState = patchedPushState;
+            history.replaceState = patchedReplaceState;
+            const popstateHandler = () => handleNavigation();
+            const hashchangeHandler = () => handleNavigation();
+            window.addEventListener('popstate', popstateHandler);
+            window.addEventListener('hashchange', hashchangeHandler);
+            this.pageviewCleanups.push(() => {
+                // Only unwind our own patch. A router (Next.js App Router, React
+                // Router, …) that patched these after us owns the current value,
+                // and assigning our saved reference back would silently throw its
+                // wrapper away. In that case ours stays in the chain, which is why
+                // `patchActive` exists: the wrapper keeps delegating to the original
+                // but stops reporting.
+                patchActive = false;
+                if (history.pushState === patchedPushState) {
+                    history.pushState = originalPushState;
+                }
+                if (history.replaceState === patchedReplaceState) {
+                    history.replaceState = originalReplaceState;
+                }
+                window.removeEventListener('popstate', popstateHandler);
+                window.removeEventListener('hashchange', hashchangeHandler);
+            });
+        }
+        /**
+         * Disable auto-pageview tracking installed by `enableAutoPageviews`.
+         * Safe to call when auto-pageviews were never enabled.
+         */
+        disableAutoPageviews() {
+            for (const cleanup of this.pageviewCleanups) {
+                cleanup();
+            }
+            this.pageviewCleanups = [];
+        }
+        /**
+         * Enable click-based outbound link tracking. Detects anchor clicks that
+         * navigate to a different origin and fires an `outbound_link` event
+         * (with `hostname` and `href` props) before the browser navigates.
+         */
+        enableAutoOutboundTracking(options = {}) {
+            if (this.outboundCleanup) {
+                return;
+            }
+            if (typeof document === 'undefined') {
+                return;
+            }
+            const includeSubdomains = options.includeSubdomains === true;
+            const clickHandler = (event) => {
+                const anchor = this.findAnchor(event.target);
+                if (!anchor || !anchor.href) {
+                    return;
+                }
+                const target = this.parseUrl(anchor.href);
+                if (!target || !this.isExternal(target, includeSubdomains)) {
+                    return;
+                }
+                this.track('outbound_link', {
+                    url: target.href,
+                    props: { hostname: target.hostname, href: target.href },
+                });
+            };
+            document.addEventListener('click', clickHandler, { capture: true });
+            this.outboundCleanup = () => document.removeEventListener('click', clickHandler, {
+                capture: true,
+            });
+        }
+        /**
+         * Disable outbound-link tracking installed by `enableAutoOutboundTracking`.
+         * Safe to call when auto-outbound was never enabled.
+         */
+        disableAutoOutboundTracking() {
+            if (this.outboundCleanup) {
+                this.outboundCleanup();
+                this.outboundCleanup = undefined;
+            }
+        }
+        /**
+         * Enable click-based download tracking. Detects anchor clicks that point
+         * at a file whose extension appears in the configured list and fires a
+         * `file_download` event with `filename`, `extension` and `href` props.
+         */
+        enableAutoDownloadTracking(options = {}) {
+            var _a;
+            if (this.downloadCleanup) {
+                return;
+            }
+            if (typeof document === 'undefined') {
+                return;
+            }
+            const extensions = ((_a = options.extensions) !== null && _a !== void 0 ? _a : DEFAULT_DOWNLOAD_EXTENSIONS).map((ext) => ext.toLowerCase().replace(/^\./, ''));
+            const extensionSet = new Set(extensions);
+            const clickHandler = (event) => {
+                var _a, _b;
+                const anchor = this.findAnchor(event.target);
+                if (!anchor || !anchor.href) {
+                    return;
+                }
+                const url = this.parseUrl(anchor.href);
+                if (!url) {
+                    return;
+                }
+                const filename = (_a = url.pathname.split('/').pop()) !== null && _a !== void 0 ? _a : '';
+                const extension = filename.includes('.')
+                    ? (_b = filename.split('.').pop()) === null || _b === void 0 ? void 0 : _b.toLowerCase()
+                    : undefined;
+                if (!extension || !extensionSet.has(extension)) {
+                    return;
+                }
+                this.track('file_download', {
+                    url: url.href,
+                    props: { filename, extension, href: url.href },
+                });
+            };
+            document.addEventListener('click', clickHandler, { capture: true });
+            this.downloadCleanup = () => document.removeEventListener('click', clickHandler, {
+                capture: true,
+            });
+        }
+        /**
+         * Disable file-download tracking installed by `enableAutoDownloadTracking`.
+         * Safe to call when auto-download was never enabled.
+         */
+        disableAutoDownloadTracking() {
+            if (this.downloadCleanup) {
+                this.downloadCleanup();
+                this.downloadCleanup = undefined;
+            }
+        }
+        /**
+         * Enable passive scroll-depth tracking. Records the maximum percent of the
+         * document scrolled and reports it on `beforeunload` and on SPA route
+         * changes. Uses a throttled passive listener so it is safe on hot paths.
+         */
+        enableAutoScrollDepth() {
+            if (this.scrollCleanups.length > 0) {
+                return;
+            }
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
+                return;
+            }
+            this.maxScrollDepth = 0;
+            this.lastScrollReport = 0;
+            const scrollHandler = () => {
+                if (this.scrollTicking) {
+                    return;
+                }
+                this.scrollTicking = true;
+                window.requestAnimationFrame(() => {
+                    const now = Date.now();
+                    if (now - this.lastScrollReport < SCROLL_DEPTH_THROTTLE_MS) {
+                        this.scrollTicking = false;
+                        return;
+                    }
+                    this.lastScrollReport = now;
+                    const depth = this.computeScrollDepth();
+                    if (depth > this.maxScrollDepth) {
+                        this.maxScrollDepth = depth;
+                    }
+                    this.scrollTicking = false;
+                });
+            };
+            const unloadHandler = () => {
+                this.flushScrollDepth(this.currentPageUrl());
+            };
+            window.addEventListener('scroll', scrollHandler, { passive: true });
+            window.addEventListener('beforeunload', unloadHandler);
+            window.addEventListener('pagehide', unloadHandler);
+            this.scrollCleanups.push(() => {
+                window.removeEventListener('scroll', scrollHandler);
+                window.removeEventListener('beforeunload', unloadHandler);
+                window.removeEventListener('pagehide', unloadHandler);
+            });
+        }
+        /**
+         * Disable scroll-depth tracking installed by `enableAutoScrollDepth`. Safe
+         * to call when auto-scroll-depth was never enabled. Any accumulated depth
+         * for the current page is dropped.
+         */
+        disableAutoScrollDepth() {
+            for (const cleanup of this.scrollCleanups) {
+                cleanup();
+            }
+            this.scrollCleanups = [];
+            this.maxScrollDepth = 0;
+            this.scrollTicking = false;
+            this.lastScrollReport = 0;
+        }
+        /**
+         * Enable active engagement-time tracking. Counts time the tab is visible
+         * and uses `visibilitychange` to exclude background time.
+         *
+         * Delivery follows Plausible's model rather than a single total at the
+         * end of the visit: an `engagement_time` event is emitted at every natural
+         * checkpoint — the tab going hidden, an SPA route change, and finally
+         * `beforeunload`/`pagehide`. Unload is kept only as a best-effort last
+         * flush; it is the least reliable moment to send anything (browsers
+         * routinely cancel in-flight requests there, and `sendBeacon` cannot set
+         * the `X-Appwrite-Project` header the endpoint requires), so it must never
+         * be the only delivery.
+         *
+         * Each event carries a **delta** — the seconds accrued since the previous
+         * flush, not a running total — so the values are additive per session and
+         * a lost event costs only its own slice.
+         *
+         * There is deliberately no periodic ping. The cadence is driven by
+         * navigation and tab switches, so request volume tracks what the visitor
+         * actually does instead of multiplying with time on page.
+         */
+        enableAutoEngagementTime() {
+            if (this.engagementCleanups.length > 0) {
+                return;
+            }
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
+                return;
+            }
+            this.engagementAccumulatedMs = 0;
+            // Do not start the clock for a tab that is already hidden (prerender,
+            // background tab restore); `visibilitychange` starts it when it is
+            // actually looked at.
+            if (document.visibilityState !== 'hidden') {
+                this.startEngagement();
+            }
+            const visibilityHandler = () => {
+                if (document.visibilityState === 'hidden') {
+                    // Flush, don't just pause. The page is still fully alive here,
+                    // which makes this the most reliable delivery point in the
+                    // whole visit — and it is the same moment Plausible reports on.
+                    this.flushEngagement(this.currentPageUrl());
+                }
+                else if (document.visibilityState === 'visible') {
+                    this.startEngagement();
+                }
+            };
+            const unloadHandler = () => {
+                this.flushEngagement(this.currentPageUrl());
+            };
+            const pageshowHandler = (event) => {
+                // When the page is restored from the back-forward cache the
+                // engagement timer is in a stopped state (flushEngagement paused
+                // it on pagehide and does not auto-restart). Kick off a fresh
+                // engagementStart so bfcache dwell time is not billed as
+                // engagement.
+                if (event.persisted) {
+                    this.startEngagement();
+                }
+            };
+            document.addEventListener('visibilitychange', visibilityHandler);
+            window.addEventListener('beforeunload', unloadHandler);
+            window.addEventListener('pagehide', unloadHandler);
+            window.addEventListener('pageshow', pageshowHandler);
+            this.engagementCleanups.push(() => {
+                document.removeEventListener('visibilitychange', visibilityHandler);
+                window.removeEventListener('beforeunload', unloadHandler);
+                window.removeEventListener('pagehide', unloadHandler);
+                window.removeEventListener('pageshow', pageshowHandler);
+            });
+        }
+        /**
+         * Disable engagement-time tracking installed by `enableAutoEngagementTime`.
+         * Safe to call when auto-engagement was never enabled. Any accumulated
+         * engagement time is dropped without being emitted.
+         */
+        disableAutoEngagementTime() {
+            for (const cleanup of this.engagementCleanups) {
+                cleanup();
+            }
+            this.engagementCleanups = [];
+            this.engagementActive = false;
+            this.engagementAccumulatedMs = 0;
+            this.engagementStart = 0;
+        }
+        /**
+         * Merge the configured `propertyId` into an event's options. Returns the
+         * caller's object untouched when no default is configured (or the event
+         * already carries one), so emitters written against the pre-`propertyId`
+         * shape keep receiving exactly what they received before.
+         */
+        withPropertyId(options) {
+            if (this.propertyId === undefined ||
+                (options === null || options === void 0 ? void 0 : options.propertyId) !== undefined) {
+                return options;
+            }
+            return Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), { propertyId: this.propertyId });
+        }
+        canTrack() {
+            if (!this.respectDoNotTrack) {
+                return true;
+            }
+            if (typeof navigator === 'undefined') {
+                return true;
+            }
+            return navigator.doNotTrack !== '1';
+        }
+        currentPageUrl() {
+            if (typeof window === 'undefined' || !window.location) {
+                return '';
+            }
+            return window.location.href;
+        }
+        findAnchor(target) {
+            let node = target;
+            while (node) {
+                if (node.tagName === 'A') {
+                    return node;
+                }
+                node = node.parentNode;
+            }
+            return null;
+        }
+        parseUrl(href) {
+            try {
+                return new URL(href, window.location.href);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        isExternal(target, includeSubdomains) {
+            if (target.protocol !== 'http:' && target.protocol !== 'https:') {
+                return false;
+            }
+            if (target.hostname === window.location.hostname) {
+                return false;
+            }
+            if (includeSubdomains) {
+                return true;
+            }
+            const root = this.rootDomain(window.location.hostname);
+            return this.rootDomain(target.hostname) !== root;
+        }
+        rootDomain(hostname) {
+            const parts = hostname.split('.');
+            if (parts.length <= 2) {
+                return hostname;
+            }
+            // Taking the last two labels is wrong wherever the registry sells names
+            // one level down: `shop.example.co.uk` and `google.co.uk` both reduce to
+            // `co.uk`, so every outbound click between two `.co.uk` sites looks
+            // internal and is dropped. Take three labels after a known two-part
+            // suffix instead.
+            //
+            // This is a heuristic, not the Public Suffix List — the full list is
+            // orders of magnitude larger than this whole file, and a tracking
+            // snippet cannot carry it. Sites on a suffix that is missing here can
+            // pass `includeSubdomains: true` to treat every other host as outbound.
+            const suffix = parts.slice(-2).join('.');
+            if (parts.length > 2 && MULTI_PART_SUFFIXES.has(suffix)) {
+                return parts.slice(-3).join('.');
+            }
+            return suffix;
+        }
+        computeScrollDepth() {
+            const scrollTop = window.scrollY || document.documentElement.scrollTop;
+            const viewport = window.innerHeight || document.documentElement.clientHeight;
+            const total = document.documentElement.scrollHeight;
+            if (total <= viewport) {
+                return 100;
+            }
+            const depth = Math.round(((scrollTop + viewport) / total) * 100);
+            return Math.max(0, Math.min(100, depth));
+        }
+        flushScrollDepth(url) {
+            if (this.scrollCleanups.length === 0) {
+                return;
+            }
+            if (this.maxScrollDepth <= 0) {
+                return;
+            }
+            this.track('scroll_depth', {
+                url,
+                scrollDepth: this.maxScrollDepth,
+            });
+            this.maxScrollDepth = 0;
+        }
+        startEngagement() {
+            if (this.engagementActive) {
+                return;
+            }
+            this.engagementActive = true;
+            this.engagementStart = Date.now();
+        }
+        pauseEngagement() {
+            if (!this.engagementActive) {
+                return;
+            }
+            this.engagementActive = false;
+            this.engagementAccumulatedMs += Date.now() - this.engagementStart;
+        }
+        flushEngagement(url) {
+            if (this.engagementCleanups.length === 0) {
+                return;
+            }
+            this.pauseEngagement();
+            // Deltas, not a running total: emit only what accrued since the last
+            // flush. `floor` plus keeping the sub-second remainder in the
+            // accumulator is what makes repeated flushes safe — nothing is emitted
+            // twice, and a visit chopped into many short segments does not lose a
+            // fraction of a second to rounding on every one of them.
+            const seconds = Math.floor(this.engagementAccumulatedMs / 1000);
+            if (seconds > 0) {
+                // Deduct before emitting so a synchronous emitter that re-enters
+                // (or throws) can never bill the same seconds again.
+                this.engagementAccumulatedMs -= seconds * 1000;
+                this.track('engagement_time', {
+                    url,
+                    engagementTime: seconds,
+                });
+            }
+            // NOTE: intentionally do NOT call startEngagement() here. flushEngagement
+            // runs on `pagehide`, which is also the last hook before the browser
+            // may freeze the page into the back-forward cache. Auto-restarting
+            // would snapshot engagementStart just before the freeze; the next
+            // pauseEngagement (after bfcache restore) would then bill the entire
+            // bfcache dwell as active engagement. Restart is driven by explicit
+            // resume signals: `pageshow` (with `persisted === true`),
+            // `visibilitychange` back to visible, or the SPA navigation flow in
+            // `enableAutoPageviews`.
+        }
+    }
+
     /**
      * Helper class to generate permission strings for resources.
      */
@@ -51277,6 +52281,40 @@
         OAuthProvider["Zoom"] = "zoom";
     })(exports.OAuthProvider || (exports.OAuthProvider = {}));
 
+    exports.AnalyticsInterval = void 0;
+    (function (AnalyticsInterval) {
+        AnalyticsInterval["OneHour"] = "1h";
+        AnalyticsInterval["OneDay"] = "1d";
+        AnalyticsInterval["OneWeek"] = "1w";
+        AnalyticsInterval["OneMonth"] = "1m";
+    })(exports.AnalyticsInterval || (exports.AnalyticsInterval = {}));
+
+    exports.AnalyticsDimension = void 0;
+    (function (AnalyticsDimension) {
+        AnalyticsDimension["Country"] = "country";
+        AnalyticsDimension["Region"] = "region";
+        AnalyticsDimension["City"] = "city";
+        AnalyticsDimension["Browser"] = "browser";
+        AnalyticsDimension["OperatingSystem"] = "operatingSystem";
+        AnalyticsDimension["Device"] = "device";
+        AnalyticsDimension["ScreenSize"] = "screenSize";
+        AnalyticsDimension["ReferrerSource"] = "referrerSource";
+        AnalyticsDimension["Channel"] = "channel";
+        AnalyticsDimension["UtmSource"] = "utmSource";
+        AnalyticsDimension["UtmMedium"] = "utmMedium";
+        AnalyticsDimension["UtmCampaign"] = "utmCampaign";
+        AnalyticsDimension["UtmContent"] = "utmContent";
+        AnalyticsDimension["UtmTerm"] = "utmTerm";
+        AnalyticsDimension["Page"] = "page";
+        AnalyticsDimension["Hostname"] = "hostname";
+        AnalyticsDimension["EntryPage"] = "entryPage";
+        AnalyticsDimension["ExitPage"] = "exitPage";
+        AnalyticsDimension["TrafficType"] = "trafficType";
+        AnalyticsDimension["BotName"] = "botName";
+        AnalyticsDimension["BotCategory"] = "botCategory";
+        AnalyticsDimension["EventName"] = "eventName";
+    })(exports.AnalyticsDimension || (exports.AnalyticsDimension = {}));
+
     exports.Browser = void 0;
     (function (Browser) {
         Browser["AvantBrowser"] = "aa";
@@ -52092,6 +53130,7 @@
         QuerySuggestionResource["ResourceTokens"] = "resourcetokens";
         QuerySuggestionResource["Transactions"] = "transactions";
         QuerySuggestionResource["TransactionLogs"] = "transactionlogs";
+        QuerySuggestionResource["AnalyticsProperties"] = "analyticsproperties";
         QuerySuggestionResource["DedicatedDatabases"] = "dedicateddatabases";
         QuerySuggestionResource["DedicatedDatabaseConfigs"] = "dedicateddatabaseconfigs";
         QuerySuggestionResource["DedicatedDatabaseRuntimes"] = "dedicateddatabaseruntimes";
@@ -52532,6 +53571,8 @@
         ProjectKeyScopes["Oauth2Read"] = "oauth2.read";
         ProjectKeyScopes["Oauth2Write"] = "oauth2.write";
         ProjectKeyScopes["Oauth2Introspect"] = "oauth2.introspect";
+        ProjectKeyScopes["AnalyticsRead"] = "analytics.read";
+        ProjectKeyScopes["AnalyticsWrite"] = "analytics.write";
     })(exports.ProjectKeyScopes || (exports.ProjectKeyScopes = {}));
 
     exports.FunctionTemplateUseCase = void 0;
@@ -53166,6 +54207,9 @@
 
     exports.UsageEventMetric = void 0;
     (function (UsageEventMetric) {
+        UsageEventMetric["AnalyticsEvents"] = "analytics.events";
+        UsageEventMetric["AnalyticsPageviews"] = "analytics.pageviews";
+        UsageEventMetric["AnalyticsBotsEvents"] = "analytics.bots.events";
         UsageEventMetric["NetworkRequests"] = "network.requests";
         UsageEventMetric["NetworkInbound"] = "network.inbound";
         UsageEventMetric["NetworkOutbound"] = "network.outbound";
@@ -53283,6 +54327,7 @@
 
     exports.UsageGaugeMetric = void 0;
     (function (UsageGaugeMetric) {
+        UsageGaugeMetric["AnalyticsProperties"] = "analytics.properties";
         UsageGaugeMetric["Teams"] = "teams";
         UsageGaugeMetric["Users"] = "users";
         UsageGaugeMetric["Messages"] = "messages";
@@ -53558,6 +54603,7 @@
     (function (ProxyRuleDeploymentResourceType) {
         ProxyRuleDeploymentResourceType["Function"] = "function";
         ProxyRuleDeploymentResourceType["Site"] = "site";
+        ProxyRuleDeploymentResourceType["DedicatedDatabase"] = "dedicatedDatabase";
     })(exports.ProxyRuleDeploymentResourceType || (exports.ProxyRuleDeploymentResourceType = {}));
 
     exports.ProxyRuleStatus = void 0;
@@ -55639,6 +56685,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     exports.Activities = Activities;
     exports.Advisor = Advisor;
     exports.Affiliates = Affiliates;
+    exports.Analytics = Analytics;
+    exports.AnalyticsTracking = AnalyticsTracking;
     exports.Apps = Apps;
     exports.AppwriteException = AppwriteException;
     exports.Assistant = Assistant;