mudbase-sdk 1.3.10 → 1.3.11

package/dist/esm/realtime.d.ts

@@ -0,0 +1,195 @@
+/**
+ * MUDBASESDK - Realtime
+ *
+ * Firebase-style realtime data listeners for the Mudbase database, layered on top of
+ * the platform's Socket.IO transport. Subscribe to live document changes with a single
+ * `.onSnapshot()` call and get an unsubscribe function back - no manual socket wiring.
+ *
+ *   const rt = new MudbaseRealtime({ projectId, token });
+ *   const unsub = rt.collection("posts").onSnapshot((change) => { ... });
+ *   const unsub = rt.doc("posts", id).onSnapshot((change) => { ... });
+ *   const unsub = rt.collection("posts").where({ published: true }).onSnapshot((snap) => { ... });
+ *
+ * This file is hand-written (not produced by OpenAPI Generator) because the realtime
+ * transport is not described by the REST OpenAPI spec. It lives in
+ * `sdk-extras/typescript/realtime.ts` in the mudbase-docs repo and is copied into the
+ * generated TypeScript (fetch) SDK's `src/` during `scripts/generate-sdks.js`, then
+ * re-exported from the package entrypoint. Edit it here, never in `generated/`.
+ */
+import { io as defaultIo } from "socket.io-client";
+import { Configuration } from "./runtime";
+/** A function that tears down a subscription. Safe to call more than once. */
+export type Unsubscribe = () => void;
+/**
+ * Document-level change actions the server emits as `db:create` / `db:update` / `db:delete`,
+ * plus collection (schema) change actions emitted as `db:collection_created` / `_updated` /
+ * `_deleted`. These are the real event names emitted by the live server, not the older
+ * `data:change` names in some server-side docs.
+ */
+export type MudbaseChangeAction = "create" | "update" | "delete" | "collection_created" | "collection_updated" | "collection_deleted";
+/**
+ * A single realtime change delivered to a `collection(...).onSnapshot()` or
+ * `doc(...).onSnapshot()` listener. Mirrors the server payload
+ * `{ projectId, collectionId, action, data, timestamp }`.
+ *
+ * For `create` / `update`, `data` is the document. For `delete`, `data` is `{ id }`.
+ * For the `collection_*` schema actions, `data` is the collection definition.
+ */
+export interface MudbaseChange<T = any> {
+    action: MudbaseChangeAction;
+    projectId: string;
+    collectionId: string;
+    data: T;
+    timestamp: string;
+}
+/**
+ * A query snapshot delivered to a `collection(...).where(query).onSnapshot()` listener.
+ * The server re-runs the query on every underlying change and emits the full matching
+ * result set as `query:change` `{ queryId, collectionId, projectId, documents, timestamp }`,
+ * so - unlike collection/doc listeners, which deliver deltas - a query listener always
+ * receives the current set of matching documents.
+ */
+export interface MudbaseQuerySnapshot<T = any> {
+    queryId: string;
+    projectId: string;
+    collectionId: string;
+    documents: T[];
+    timestamp: string;
+}
+/** Called when the server rejects a subscription or the socket reports an error. */
+export type SnapshotErrorHandler = (error: Error) => void;
+/**
+ * Options for {@link MudbaseRealtime}.
+ *
+ * Supply the same credentials you already use with the REST SDK: either pass a
+ * `Configuration` (its `accessToken`/`basePath` are reused) or a raw `token`/`getToken`.
+ */
+export interface MudbaseRealtimeOptions {
+    /** The Mudbase project id every subscription is scoped to. Required. */
+    projectId: string;
+    /**
+     * A JWT for the Socket.IO handshake. Can be a string or a (sync/async) function that
+     * returns one - use the function form when the token is refreshed over time. If omitted,
+     * `configuration.accessToken` is used.
+     */
+    token?: string | (() => string | Promise<string>);
+    /**
+     * The REST SDK `Configuration`. When present, its `accessToken` is reused as the socket
+     * token (unless `token` is given) and its `basePath` as the server URL (unless `basePath`
+     * is given).
+     */
+    configuration?: Configuration;
+    /** Server URL. Defaults to `configuration.basePath`, then the SDK's `BASE_PATH`. */
+    basePath?: string;
+    /** Extra options forwarded to the underlying Socket.IO client (e.g. `transports`). */
+    socketOptions?: Record<string, any>;
+    /**
+     * Inject a Socket.IO `io(...)` factory (mainly for testing). Defaults to the real
+     * `socket.io-client` `io`.
+     */
+    ioClient?: typeof defaultIo;
+}
+type ChangeListener = {
+    kind: "collection";
+    collectionId: string;
+    /** When set, only changes to this document id are delivered (doc listener). */
+    documentId?: string;
+    cb: (change: MudbaseChange) => void;
+    onError?: SnapshotErrorHandler;
+};
+type QueryListener = {
+    kind: "query";
+    queryId: string;
+    collectionId: string;
+    query: Record<string, any>;
+    cb: (snapshot: MudbaseQuerySnapshot) => void;
+    onError?: SnapshotErrorHandler;
+};
+/**
+ * A live handle to a Mudbase database, exposing Firebase-style `.collection()` / `.doc()`
+ * accessors whose `.onSnapshot()` delivers realtime changes over Socket.IO.
+ *
+ * One `MudbaseRealtime` owns one socket connection, shared across every subscription. The
+ * connection is opened lazily on the first `.onSnapshot()` and closed by {@link close}.
+ * Server-side room subscriptions are ref-counted, and all active subscriptions are
+ * re-established automatically after a reconnect.
+ */
+export declare class MudbaseRealtime {
+    private readonly projectId;
+    private readonly basePath;
+    private readonly socketOptions;
+    private readonly ioClient;
+    private readonly tokenSource?;
+    private readonly configuration?;
+    private socket;
+    private readonly listeners;
+    /** collectionId -> number of active server-room subscriptions (collection + doc listeners). */
+    private readonly collectionRefs;
+    constructor(options: MudbaseRealtimeOptions);
+    /** A reference to a collection you can subscribe to or narrow with `.where()`. */
+    collection(collectionId: string): CollectionRef;
+    /** A reference to a single document you can subscribe to. */
+    doc(collectionId: string, documentId: string): DocumentRef;
+    /** Close the underlying socket and drop all subscriptions. */
+    close(): void;
+    /** True once the socket has connected at least once and is currently connected. */
+    get connected(): boolean;
+    private resolveToken;
+    private ensureSocket;
+    private sendSubscribe;
+    private emitError;
+    private dispatchChange;
+    private dispatchQuery;
+    /** @internal */
+    _addCollectionListener(l: ChangeListener): Unsubscribe;
+    private _removeCollectionListener;
+    /** @internal */
+    _addQueryListener(l: QueryListener): Unsubscribe;
+}
+/** A reference to a collection. Subscribe with `.onSnapshot()` or narrow with `.where()`. */
+export declare class CollectionRef {
+    private readonly rt;
+    private readonly collectionId;
+    constructor(rt: MudbaseRealtime, collectionId: string);
+    /**
+     * Listen for every document change in the collection (`create` / `update` / `delete`) and
+     * collection-schema changes. Returns an unsubscribe function.
+     */
+    onSnapshot(cb: (change: MudbaseChange) => void, onError?: SnapshotErrorHandler): Unsubscribe;
+    /** Alias for {@link onSnapshot}. */
+    subscribe(cb: (change: MudbaseChange) => void, onError?: SnapshotErrorHandler): Unsubscribe;
+    /** Narrow this collection to documents matching a query (Mongo-style filter). */
+    where(query: Record<string, any>): QueryRef;
+}
+/** A reference to a single document. */
+export declare class DocumentRef {
+    private readonly rt;
+    private readonly collectionId;
+    private readonly documentId;
+    constructor(rt: MudbaseRealtime, collectionId: string, documentId: string);
+    /**
+     * Listen for changes to this one document. Implemented by subscribing to the document's
+     * collection and filtering to this id client-side - the live server delivers document
+     * `db:*` events on the collection room, not a per-document room. Returns an unsubscribe
+     * function.
+     */
+    onSnapshot(cb: (change: MudbaseChange) => void, onError?: SnapshotErrorHandler): Unsubscribe;
+    /** Alias for {@link onSnapshot}. */
+    subscribe(cb: (change: MudbaseChange) => void, onError?: SnapshotErrorHandler): Unsubscribe;
+}
+/** A reference to a filtered query. Subscribe with `.onSnapshot()` for live result sets. */
+export declare class QueryRef {
+    private readonly rt;
+    private readonly collectionId;
+    private readonly query;
+    constructor(rt: MudbaseRealtime, collectionId: string, query: Record<string, any>);
+    /**
+     * Listen for the live set of documents matching this query. The server re-runs the query
+     * on every underlying change and emits the full matching set. Returns an unsubscribe
+     * function.
+     */
+    onSnapshot(cb: (snapshot: MudbaseQuerySnapshot) => void, onError?: SnapshotErrorHandler): Unsubscribe;
+    /** Alias for {@link onSnapshot}. */
+    subscribe(cb: (snapshot: MudbaseQuerySnapshot) => void, onError?: SnapshotErrorHandler): Unsubscribe;
+}
+export {};

package/dist/esm/realtime.js

@@ -0,0 +1,374 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * MUDBASESDK - Realtime
+ *
+ * Firebase-style realtime data listeners for the Mudbase database, layered on top of
+ * the platform's Socket.IO transport. Subscribe to live document changes with a single
+ * `.onSnapshot()` call and get an unsubscribe function back - no manual socket wiring.
+ *
+ *   const rt = new MudbaseRealtime({ projectId, token });
+ *   const unsub = rt.collection("posts").onSnapshot((change) => { ... });
+ *   const unsub = rt.doc("posts", id).onSnapshot((change) => { ... });
+ *   const unsub = rt.collection("posts").where({ published: true }).onSnapshot((snap) => { ... });
+ *
+ * This file is hand-written (not produced by OpenAPI Generator) because the realtime
+ * transport is not described by the REST OpenAPI spec. It lives in
+ * `sdk-extras/typescript/realtime.ts` in the mudbase-docs repo and is copied into the
+ * generated TypeScript (fetch) SDK's `src/` during `scripts/generate-sdks.js`, then
+ * re-exported from the package entrypoint. Edit it here, never in `generated/`.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { io as defaultIo } from "socket.io-client";
+import { BASE_PATH } from "./runtime";
+const DB_CHANGE_EVENTS = [
+    "db:create",
+    "db:update",
+    "db:delete",
+    "db:collection_created",
+    "db:collection_updated",
+    "db:collection_deleted",
+];
+let queryCounter = 0;
+function nextQueryId() {
+    queryCounter += 1;
+    const rand = Math.random().toString(36).slice(2, 10);
+    return `q_${Date.now().toString(36)}_${queryCounter}_${rand}`;
+}
+function docIdOf(data) {
+    var _a;
+    if (data == null || typeof data !== "object")
+        return undefined;
+    const raw = (_a = data._id) !== null && _a !== void 0 ? _a : data.id;
+    return raw == null ? undefined : String(raw);
+}
+/**
+ * A live handle to a Mudbase database, exposing Firebase-style `.collection()` / `.doc()`
+ * accessors whose `.onSnapshot()` delivers realtime changes over Socket.IO.
+ *
+ * One `MudbaseRealtime` owns one socket connection, shared across every subscription. The
+ * connection is opened lazily on the first `.onSnapshot()` and closed by {@link close}.
+ * Server-side room subscriptions are ref-counted, and all active subscriptions are
+ * re-established automatically after a reconnect.
+ */
+export class MudbaseRealtime {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        this.socket = null;
+        this.listeners = new Set();
+        /** collectionId -> number of active server-room subscriptions (collection + doc listeners). */
+        this.collectionRefs = new Map();
+        if (!options || !options.projectId) {
+            throw new Error("MudbaseRealtime: `projectId` is required");
+        }
+        this.projectId = options.projectId;
+        this.configuration = options.configuration;
+        this.tokenSource = options.token;
+        this.basePath = ((_c = (_a = options.basePath) !== null && _a !== void 0 ? _a : (_b = options.configuration) === null || _b === void 0 ? void 0 : _b.basePath) !== null && _c !== void 0 ? _c : BASE_PATH).replace(/\/+$/, "");
+        this.socketOptions = (_d = options.socketOptions) !== null && _d !== void 0 ? _d : {};
+        this.ioClient = (_e = options.ioClient) !== null && _e !== void 0 ? _e : defaultIo;
+    }
+    /** A reference to a collection you can subscribe to or narrow with `.where()`. */
+    collection(collectionId) {
+        if (!collectionId)
+            throw new Error("MudbaseRealtime.collection: `collectionId` is required");
+        return new CollectionRef(this, collectionId);
+    }
+    /** A reference to a single document you can subscribe to. */
+    doc(collectionId, documentId) {
+        if (!collectionId)
+            throw new Error("MudbaseRealtime.doc: `collectionId` is required");
+        if (!documentId)
+            throw new Error("MudbaseRealtime.doc: `documentId` is required");
+        return new DocumentRef(this, collectionId, documentId);
+    }
+    /** Close the underlying socket and drop all subscriptions. */
+    close() {
+        this.listeners.clear();
+        this.collectionRefs.clear();
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+    /** True once the socket has connected at least once and is currently connected. */
+    get connected() {
+        var _a;
+        return !!((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected);
+    }
+    // --- internal: token resolution -------------------------------------------------
+    resolveToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const src = this.tokenSource;
+            if (typeof src === "string")
+                return src;
+            if (typeof src === "function")
+                return yield src();
+            // Fall back to the REST SDK Configuration's accessToken (string or function form).
+            const at = (_a = this.configuration) === null || _a === void 0 ? void 0 : _a.accessToken;
+            if (typeof at === "string")
+                return at;
+            if (typeof at === "function")
+                return yield at();
+            return undefined;
+        });
+    }
+    // --- internal: connection lifecycle ---------------------------------------------
+    ensureSocket() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.socket)
+                return this.socket;
+            const token = yield this.resolveToken();
+            if (!token) {
+                throw new Error("MudbaseRealtime: no auth token available. Pass `token`, `getToken`, or a `configuration` with an `accessToken`.");
+            }
+            // Guard against a concurrent ensureSocket() having created the socket while we awaited.
+            if (this.socket)
+                return this.socket;
+            const socket = this.ioClient(this.basePath, Object.assign({ auth: { token }, transports: ["websocket", "polling"] }, this.socketOptions));
+            this.socket = socket;
+            // Re-establish every active subscription after a (re)connect. Socket.IO rooms are
+            // per-connection on the server, so a reconnect starts with no rooms joined.
+            socket.on("connect", () => {
+                for (const l of this.listeners)
+                    this.sendSubscribe(socket, l);
+            });
+            // Surface connection/handshake failures to every listener's error handler.
+            socket.on("connect_error", (err) => this.emitError(err));
+            socket.on("error", (payload) => {
+                var _a;
+                const message = typeof payload === "string" ? payload : (_a = payload === null || payload === void 0 ? void 0 : payload.message) !== null && _a !== void 0 ? _a : "Realtime error";
+                this.emitError(new Error(message));
+            });
+            for (const event of DB_CHANGE_EVENTS) {
+                socket.on(event, (payload) => this.dispatchChange(payload));
+            }
+            socket.on("query:change", (payload) => this.dispatchQuery(payload));
+            return socket;
+        });
+    }
+    sendSubscribe(socket, l) {
+        if (l.kind === "query") {
+            socket.emit("subscribe:query", {
+                projectId: this.projectId,
+                collectionId: l.collectionId,
+                queryId: l.queryId,
+                query: l.query,
+            });
+        }
+        else {
+            socket.emit("subscribe:collection", {
+                projectId: this.projectId,
+                collectionId: l.collectionId,
+            });
+        }
+    }
+    emitError(error) {
+        var _a;
+        for (const l of this.listeners)
+            (_a = l.onError) === null || _a === void 0 ? void 0 : _a.call(l, error);
+    }
+    dispatchChange(payload) {
+        var _a;
+        if (!payload || typeof payload !== "object")
+            return;
+        const change = {
+            action: payload.action,
+            projectId: payload.projectId,
+            collectionId: payload.collectionId,
+            data: payload.data,
+            timestamp: payload.timestamp,
+        };
+        for (const l of this.listeners) {
+            if (l.kind !== "collection")
+                continue;
+            if (l.collectionId !== change.collectionId)
+                continue;
+            if (l.documentId) {
+                // Doc listener: only forward changes to the one document. `delete` carries `{ id }`,
+                // `create`/`update` carry the document itself (id under `_id` or `id`).
+                if (docIdOf(change.data) !== l.documentId)
+                    continue;
+            }
+            try {
+                l.cb(change);
+            }
+            catch (err) {
+                (_a = l.onError) === null || _a === void 0 ? void 0 : _a.call(l, err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    }
+    dispatchQuery(payload) {
+        var _a;
+        if (!payload || typeof payload !== "object")
+            return;
+        const snapshot = {
+            queryId: payload.queryId,
+            projectId: payload.projectId,
+            collectionId: payload.collectionId,
+            documents: Array.isArray(payload.documents) ? payload.documents : [],
+            timestamp: payload.timestamp,
+        };
+        for (const l of this.listeners) {
+            if (l.kind !== "query")
+                continue;
+            if (l.queryId !== snapshot.queryId)
+                continue;
+            try {
+                l.cb(snapshot);
+            }
+            catch (err) {
+                (_a = l.onError) === null || _a === void 0 ? void 0 : _a.call(l, err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    }
+    // --- internal: subscription registration (called by the ref classes) -------------
+    /** @internal */
+    _addCollectionListener(l) {
+        var _a;
+        this.listeners.add(l);
+        const refs = ((_a = this.collectionRefs.get(l.collectionId)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.collectionRefs.set(l.collectionId, refs);
+        // Open the socket (lazily) and join the collection room. Only the first listener for a
+        // given collection sends `subscribe:collection`; the reconnect handler re-sends for all.
+        this.ensureSocket()
+            .then((socket) => {
+            if (!this.listeners.has(l))
+                return; // unsubscribed before connect resolved
+            if (refs === 1 || !socket.connected) {
+                if (socket.connected)
+                    this.sendSubscribe(socket, l);
+                // if not yet connected, the "connect" handler will send it
+            }
+        })
+            .catch((err) => { var _a; return (_a = l.onError) === null || _a === void 0 ? void 0 : _a.call(l, err instanceof Error ? err : new Error(String(err))); });
+        return () => this._removeCollectionListener(l);
+    }
+    _removeCollectionListener(l) {
+        var _a, _b;
+        if (!this.listeners.delete(l))
+            return;
+        const refs = ((_a = this.collectionRefs.get(l.collectionId)) !== null && _a !== void 0 ? _a : 1) - 1;
+        if (refs <= 0) {
+            this.collectionRefs.delete(l.collectionId);
+            if ((_b = this.socket) === null || _b === void 0 ? void 0 : _b.connected) {
+                this.socket.emit("unsubscribe:collection", { collectionId: l.collectionId });
+            }
+        }
+        else {
+            this.collectionRefs.set(l.collectionId, refs);
+        }
+    }
+    /** @internal */
+    _addQueryListener(l) {
+        this.listeners.add(l);
+        this.ensureSocket()
+            .then((socket) => {
+            if (!this.listeners.has(l))
+                return;
+            if (socket.connected)
+                this.sendSubscribe(socket, l);
+            // otherwise the "connect" handler sends it
+        })
+            .catch((err) => { var _a; return (_a = l.onError) === null || _a === void 0 ? void 0 : _a.call(l, err instanceof Error ? err : new Error(String(err))); });
+        return () => {
+            var _a;
+            if (!this.listeners.delete(l))
+                return;
+            if ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected) {
+                this.socket.emit("unsubscribe:query", { queryId: l.queryId });
+            }
+        };
+    }
+}
+/** A reference to a collection. Subscribe with `.onSnapshot()` or narrow with `.where()`. */
+export class CollectionRef {
+    constructor(rt, collectionId) {
+        this.rt = rt;
+        this.collectionId = collectionId;
+    }
+    /**
+     * Listen for every document change in the collection (`create` / `update` / `delete`) and
+     * collection-schema changes. Returns an unsubscribe function.
+     */
+    onSnapshot(cb, onError) {
+        return this.rt._addCollectionListener({
+            kind: "collection",
+            collectionId: this.collectionId,
+            cb,
+            onError,
+        });
+    }
+    /** Alias for {@link onSnapshot}. */
+    subscribe(cb, onError) {
+        return this.onSnapshot(cb, onError);
+    }
+    /** Narrow this collection to documents matching a query (Mongo-style filter). */
+    where(query) {
+        return new QueryRef(this.rt, this.collectionId, query !== null && query !== void 0 ? query : {});
+    }
+}
+/** A reference to a single document. */
+export class DocumentRef {
+    constructor(rt, collectionId, documentId) {
+        this.rt = rt;
+        this.collectionId = collectionId;
+        this.documentId = documentId;
+    }
+    /**
+     * Listen for changes to this one document. Implemented by subscribing to the document's
+     * collection and filtering to this id client-side - the live server delivers document
+     * `db:*` events on the collection room, not a per-document room. Returns an unsubscribe
+     * function.
+     */
+    onSnapshot(cb, onError) {
+        return this.rt._addCollectionListener({
+            kind: "collection",
+            collectionId: this.collectionId,
+            documentId: this.documentId,
+            cb,
+            onError,
+        });
+    }
+    /** Alias for {@link onSnapshot}. */
+    subscribe(cb, onError) {
+        return this.onSnapshot(cb, onError);
+    }
+}
+/** A reference to a filtered query. Subscribe with `.onSnapshot()` for live result sets. */
+export class QueryRef {
+    constructor(rt, collectionId, query) {
+        this.rt = rt;
+        this.collectionId = collectionId;
+        this.query = query;
+    }
+    /**
+     * Listen for the live set of documents matching this query. The server re-runs the query
+     * on every underlying change and emits the full matching set. Returns an unsubscribe
+     * function.
+     */
+    onSnapshot(cb, onError) {
+        return this.rt._addQueryListener({
+            kind: "query",
+            queryId: nextQueryId(),
+            collectionId: this.collectionId,
+            query: this.query,
+            cb,
+            onError,
+        });
+    }
+    /** Alias for {@link onSnapshot}. */
+    subscribe(cb, onError) {
+        return this.onSnapshot(cb, onError);
+    }
+}

package/dist/esm/runtime.d.ts

@@ -1,8 +1,8 @@
 /**
  * MUDBASESDK
- * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 📡 Block-based multi-chain wallet monitoring (ETH/UTXO scanners, GetBlock, scanner metrics API) - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
+ * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
  *
- * The version of the OpenAPI document: 1.3.10
+ * The version of the OpenAPI document: 1.3.11
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/esm/runtime.js

@@ -2,9 +2,9 @@
 /* eslint-disable */
 /**
  * MUDBASESDK
- * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 📡 Block-based multi-chain wallet monitoring (ETH/UTXO scanners, GetBlock, scanner metrics API) - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
+ * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
  *
- * The version of the OpenAPI document: 1.3.10
+ * The version of the OpenAPI document: 1.3.11
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './runtime';
 export * from './apis/index';
 export * from './models/index';
+export * from './realtime';

package/dist/index.js

@@ -19,3 +19,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./runtime"), exports);
 __exportStar(require("./apis/index"), exports);
 __exportStar(require("./models/index"), exports);
+__exportStar(require("./realtime"), exports);

package/dist/models/AcceptInvite201Response.d.ts

@@ -1,8 +1,8 @@
 /**
  * MUDBASESDK
- * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 📡 Block-based multi-chain wallet monitoring (ETH/UTXO scanners, GetBlock, scanner metrics API) - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
+ * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
  *
- * The version of the OpenAPI document: 1.3.10
+ * The version of the OpenAPI document: 1.3.11
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/models/AcceptInvite201Response.js

@@ -3,9 +3,9 @@
 /* eslint-disable */
 /**
  * MUDBASESDK
- * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 📡 Block-based multi-chain wallet monitoring (ETH/UTXO scanners, GetBlock, scanner metrics API) - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
+ * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
  *
- * The version of the OpenAPI document: 1.3.10
+ * The version of the OpenAPI document: 1.3.11
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/dist/models/AcceptInvite201ResponseUser.d.ts

@@ -1,8 +1,8 @@
 /**
  * MUDBASESDK
- * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 📡 Block-based multi-chain wallet monitoring (ETH/UTXO scanners, GetBlock, scanner metrics API) - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
+ * MUDBASE is a scalable, real-time, and secure Backend-as-a-Service (BaaS) platform  designed for modern applications. Built with custom logic, it offers fine-grained  control, extensibility, and enterprise-grade security.  ## Features - 🔐 Multi-provider authentication (30+ OAuth providers) - 📊 Real-time database with collections - 📁 File storage and management - 🔑 API key management with permissions - 🔗 Webhook system with retry logic - ⚡ Serverless functions - 💬 Multi-channel messaging (Push, Email, SMS) - 📈 Usage analytics and monitoring - 🌐 Real-time WebSocket events - 🔍 Full-text search capabilities - 💳 Billing: fiat only for project subscriptions and org BaaS checkout (platform fee split). On-chain billing is not exposed on these APIs (optional `crypto-payment-module/` in repo, not mounted by default). - 🏢 Enterprise / Phase 4: custom domains on Growth, Scale, and Enterprise (TXT DNS at `_mudbase-verify.<hostname>`); `settings.customDomainAddon` is optional (billing/legacy); dedicated DB migration script, periodic DNS recheck job, optional `infrastructureEnvironments[]` and edge/metering fields on `dedicated`.
  *
- * The version of the OpenAPI document: 1.3.10
+ * The version of the OpenAPI document: 1.3.11
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).