mudbase-sdk 1.3.11 → 1.3.13

package/src/models/WebPushUnsubscribeResponse.ts

@@ -0,0 +1,81 @@
+/* tslint:disable */
+/* 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). - 🏢 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.13
+ * Contact: support@mudbase.dev
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { WebPushUnsubscribeResponseData } from './WebPushUnsubscribeResponseData';
+import {
+    WebPushUnsubscribeResponseDataFromJSON,
+    WebPushUnsubscribeResponseDataFromJSONTyped,
+    WebPushUnsubscribeResponseDataToJSON,
+    WebPushUnsubscribeResponseDataToJSONTyped,
+} from './WebPushUnsubscribeResponseData';
+
+/**
+ * 
+ * @export
+ * @interface WebPushUnsubscribeResponse
+ */
+export interface WebPushUnsubscribeResponse {
+    /**
+     * 
+     * @type {boolean}
+     * @memberof WebPushUnsubscribeResponse
+     */
+    success?: boolean;
+    /**
+     * 
+     * @type {WebPushUnsubscribeResponseData}
+     * @memberof WebPushUnsubscribeResponse
+     */
+    data?: WebPushUnsubscribeResponseData;
+}
+
+/**
+ * Check if a given object implements the WebPushUnsubscribeResponse interface.
+ */
+export function instanceOfWebPushUnsubscribeResponse(value: object): value is WebPushUnsubscribeResponse {
+    return true;
+}
+
+export function WebPushUnsubscribeResponseFromJSON(json: any): WebPushUnsubscribeResponse {
+    return WebPushUnsubscribeResponseFromJSONTyped(json, false);
+}
+
+export function WebPushUnsubscribeResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): WebPushUnsubscribeResponse {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'success': json['success'] == null ? undefined : json['success'],
+        'data': json['data'] == null ? undefined : WebPushUnsubscribeResponseDataFromJSON(json['data']),
+    };
+}
+
+export function WebPushUnsubscribeResponseToJSON(json: any): WebPushUnsubscribeResponse {
+    return WebPushUnsubscribeResponseToJSONTyped(json, false);
+}
+
+export function WebPushUnsubscribeResponseToJSONTyped(value?: WebPushUnsubscribeResponse | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'success': value['success'],
+        'data': WebPushUnsubscribeResponseDataToJSON(value['data']),
+    };
+}
+

package/src/models/WebPushUnsubscribeResponseData.ts

@@ -0,0 +1,66 @@
+/* tslint:disable */
+/* 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). - 🏢 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.13
+ * Contact: support@mudbase.dev
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+/**
+ * 
+ * @export
+ * @interface WebPushUnsubscribeResponseData
+ */
+export interface WebPushUnsubscribeResponseData {
+    /**
+     * True if a matching subscription was removed; false if none was registered.
+     * 
+     * @type {boolean}
+     * @memberof WebPushUnsubscribeResponseData
+     */
+    removed?: boolean;
+}
+
+/**
+ * Check if a given object implements the WebPushUnsubscribeResponseData interface.
+ */
+export function instanceOfWebPushUnsubscribeResponseData(value: object): value is WebPushUnsubscribeResponseData {
+    return true;
+}
+
+export function WebPushUnsubscribeResponseDataFromJSON(json: any): WebPushUnsubscribeResponseData {
+    return WebPushUnsubscribeResponseDataFromJSONTyped(json, false);
+}
+
+export function WebPushUnsubscribeResponseDataFromJSONTyped(json: any, ignoreDiscriminator: boolean): WebPushUnsubscribeResponseData {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'removed': json['removed'] == null ? undefined : json['removed'],
+    };
+}
+
+export function WebPushUnsubscribeResponseDataToJSON(json: any): WebPushUnsubscribeResponseData {
+    return WebPushUnsubscribeResponseDataToJSONTyped(json, false);
+}
+
+export function WebPushUnsubscribeResponseDataToJSONTyped(value?: WebPushUnsubscribeResponseData | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'removed': value['removed'],
+    };
+}
+

package/src/models/WebhookListResponse.ts

@@ -4,7 +4,7 @@
  * 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). - 🏢 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.11
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/models/WebhookLog.ts

@@ -4,7 +4,7 @@
  * 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). - 🏢 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.11
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/models/WebhookLogResponse.ts

@@ -4,7 +4,7 @@
  * 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). - 🏢 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.11
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/models/WebhookStatsResponse.ts

@@ -4,7 +4,7 @@
  * 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). - 🏢 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.11
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/models/WebhookStatsResponseEventStatsInner.ts

@@ -4,7 +4,7 @@
  * 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). - 🏢 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.11
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/models/WebhookStatsResponseStatusStatsInner.ts

@@ -4,7 +4,7 @@
  * 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). - 🏢 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.11
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/models/index.ts

@@ -439,6 +439,11 @@ export * from './ProjectUsageStatsResponseProject';
 export * from './ProjectUsageSummaryResponse';
 export * from './ProvisionEnterpriseRequest';
 export * from './PushNotificationRequest';
+export * from './PushSentResponse';
+export * from './PushSentResponseData';
+export * from './PushSentResponseDataChannels';
+export * from './PushSentResponseDataChannelsFcm';
+export * from './PushSentResponseDataChannelsWebPush';
 export * from './PutChatE2eeKey200Response';
 export * from './PutChatE2eeKey200ResponseData';
 export * from './PutChatE2eeKeyRequest';
@@ -574,6 +579,21 @@ export * from './VerifyPayment200Response';
 export * from './VerifyPayment200ResponseData';
 export * from './VerifyPayment200ResponseDataSubscription';
 export * from './VerifyProjectEmailSmtpDomainRequest';
+export * from './WebPushConfigPatchRequest';
+export * from './WebPushConfigResponse';
+export * from './WebPushConfigResponseData';
+export * from './WebPushPublicKeyResponse';
+export * from './WebPushPublicKeyResponseData';
+export * from './WebPushSubscribeRequest';
+export * from './WebPushSubscribeResponse';
+export * from './WebPushSubscribeResponseData';
+export * from './WebPushSubscription';
+export * from './WebPushSubscriptionKeys';
+export * from './WebPushSubscriptionListResponse';
+export * from './WebPushSubscriptionSummary';
+export * from './WebPushUnsubscribeRequest';
+export * from './WebPushUnsubscribeResponse';
+export * from './WebPushUnsubscribeResponseData';
 export * from './WebhookListResponse';
 export * from './WebhookLog';
 export * from './WebhookLogResponse';

package/src/query.ts

@@ -0,0 +1,356 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * MUDBASESDK - Fluent query builder
+ *
+ * A Supabase/Appwrite-style chainable query builder layered on top of the generated `DataApi`:
+ *
+ *   const mudbase = new MudbaseQuery({ projectId, configuration });
+ *   const { data } = await mudbase
+ *     .from("posts")
+ *     .select("title", "status")
+ *     .eq("status", "published")
+ *     .eq("authorId.name", "Ada")
+ *     .populate("authorId")
+ *     .sort("-createdAt")
+ *     .limit(10)
+ *     .execute();
+ *
+ * This file is hand-written (not produced by OpenAPI Generator) because
+ * `GET /api/data/projects/{projectId}/collections/{collectionId}/data` accepts several query
+ * params the OpenAPI spec cannot describe as typed fields - most importantly, an unbounded set
+ * of `<relationshipPath>.<field>=value` deep-filter keys (see the backend's
+ * `services/relationshipService.js` `resolveRelationshipFilters` / `resolveRelationshipSortKeys`)
+ * whose *names*, not just their values, are caller-chosen. The generated `DataApi.listData()`'s
+ * typed `ListDataRequest` only covers `page` / `limit` / `sort` / `filter` (confirmed against
+ * `generated/typescript-sdk/src/apis/DataApi.ts` - no `fields`, `populate`, or dotted deep-filter
+ * keys) - this builder is the one place that also emits those dynamic dotted-key query params,
+ * plus `populate` and `fields`.
+ *
+ * It lives in `sdk-extras/typescript/query.ts` in the mudbase-docs repo and is copied into the
+ * generated TypeScript (fetch) SDK's `src/` by `scripts/generate-sdks.js`, then re-exported from
+ * the package entrypoint. Edit it here, never in `generated/`.
+ *
+ * Imports are pre-pointed at the fetch flavor's `./runtime` (`Configuration` + `BASE_PATH`), so
+ * it resolves against exactly what ships to npm - same convention as `realtime.ts`/`webPush.ts`
+ * in this directory. Auth and the HTTP call are hand-assembled with the platform `fetch` (not
+ * `runtime.BaseAPI.request`), matching `webPush.ts`'s style, since this one endpoint's query
+ * shape is what the generated request-builder can't fully express; everything else (bearer/API
+ * key resolution, base path fallback) mirrors the generated `Configuration`'s own semantics
+ * exactly, so it behaves identically to every generated `*Api` call.
+ *
+ * DESIGN NOTES (this is the reference implementation later per-language typed codegen is meant
+ * to follow - see the PR description for the same rationale in one place):
+ *
+ * 1. `.eq(field, value)` routes on whether `field` contains a "." - exactly the same rule the
+ *    backend route itself uses (`routes/data.js`'s `RESERVED_LIST_QUERY_KEYS` set plus "any
+ *    other dotted query key is a relationship-filter candidate"). A plain field name
+ *    (`"status"`) is merged into the JSON `filter` object; a dotted field name
+ *    (`"authorId.name"`) becomes its own top-level query-string key. The SDK does not validate
+ *    that a dotted `.eq()` path names a real declared relationship - the server already treats
+ *    an unrecognized one as a no-op filter key (silently ignored, not an error), so client-side
+ *    validation would require an extra round trip to fetch the project's relationship graph for
+ *    no real safety benefit.
+ * 2. `.sort(...fields)` is intentionally a thin pass-through: each argument is a plain sort
+ *    token exactly as the backend's `?sort=` parses it (`-` prefix for descending, dotted paths
+ *    resolve through a declared relationship server-side per `resolveRelationshipSortKeys`).
+ *    Calling `.sort()` more than once appends further sort keys (matching the common
+ *    `.order().order()` compound-sort idiom other query builders use); calling it again for a
+ *    field already present replaces that field's position and direction with the new call
+ *    rather than duplicating it.
+ * 3. `.populate(...keys)` accepts the same dotted nested-key syntax `?populate=` already accepts
+ *    (e.g. `"comments.authorId"`) - this builder does not attempt to model the relationship
+ *    graph client-side, it only accumulates and de-duplicates the requested keys.
+ * 4. There is no `.gt()`/`.lt()`/`.in()` etc. in this first pass - only `.eq()`, matching the
+ *    task's requested surface. A future pass can extend `filter` with Mongo-style operator
+ *    objects (`{ $gt: value }`) the same `querySanitizer.sanitizeFilter` on the backend already
+ *    accepts; `.eq()`'s plain-field branch already writes into that same `filter` object, so
+ *    adding e.g. `.gt(field, value)` later only needs to merge `{ [field]: { $gt: value } }`
+ *    into it - no shape change to this builder's query-compilation contract.
+ * 5. `toQueryParams()` is a pure function (no network, no auth) so the query-compilation logic
+ *    is unit-testable on its own, independent of `execute()`'s HTTP/auth plumbing.
+ * 6. Auth resolution deliberately checks both a bearer token and an API key (like `webPush.ts`
+ *    does), rather than only one - the backend's `GET .../data` route accepts
+ *    `OrgBearerAuth` / `ProjectBearerAuth` / `ApiKeyAuth` (see its own doc comment in
+ *    `DataApi.ts`), so a caller configured with only an `apiKey` must still get an authenticated
+ *    request out of this builder.
+ */
+
+import { BASE_PATH, Configuration } from "./runtime";
+
+/** Options for {@link MudbaseQuery}. Mirrors {@link MudbaseWebPushOptions}'s auth/base-path shape. */
+export interface MudbaseQueryOptions {
+  /** The Mudbase project id every `.from(...)` call is scoped to. Required. */
+  projectId: string;
+  /**
+   * The REST SDK `Configuration`. When present, its `basePath` is reused as the server URL and
+   * its `accessToken` / `apiKey` as the credential for the request.
+   */
+  configuration?: Configuration;
+  /** Server URL. Defaults to `configuration.basePath`, then the SDK's `BASE_PATH`. */
+  basePath?: string;
+  /**
+   * Bearer token (a string, or a 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>);
+  /** API key for programmatic access (`X-API-Key`). If omitted, `configuration.apiKey` is used. */
+  apiKey?: string;
+  /** Injectable `fetch` (defaults to the global `fetch`); mainly for tests. */
+  fetchImpl?: typeof fetch;
+}
+
+/** The compiled query-string params a {@link MudbaseQueryBuilder} chain resolves to. */
+export interface CompiledQueryParams {
+  page?: number;
+  limit?: number;
+  sort?: string;
+  filter?: string;
+  fields?: string;
+  populate?: string;
+  /** Deep/relationship-field filter keys, e.g. `{ "authorId.name": "Ada" }`. */
+  [dottedFilterKey: string]: string | number | undefined;
+}
+
+/** A single document as returned by `.execute()` - matches the generated `DataListResponse`'s `data[]` shape. */
+export type MudbaseQueryDocument = Record<string, unknown>;
+
+/** The response shape `.execute()` resolves to - matches the generated `DataListResponse`. */
+export interface MudbaseQueryResponse<T = MudbaseQueryDocument> {
+  data?: T[];
+  pagination?: {
+    page?: number;
+    limit?: number;
+    total?: number;
+    pages?: number;
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Entry point: `new MudbaseQuery({ projectId, configuration }).from("posts")...`.
+ * Construct one per project (or reuse the same `Configuration` your other SDK calls use).
+ */
+export class MudbaseQuery {
+  private readonly projectId: string;
+  private readonly configuration?: Configuration;
+  private readonly basePath: string;
+  private readonly tokenSource?: string | (() => string | Promise<string>);
+  private readonly apiKeyValue?: string;
+  private readonly fetchImpl: typeof fetch;
+
+  constructor(options: MudbaseQueryOptions) {
+    if (!options || !options.projectId) {
+      throw new Error("MudbaseQuery: `projectId` is required");
+    }
+    this.projectId = options.projectId;
+    this.configuration = options.configuration;
+    this.tokenSource = options.token;
+    this.apiKeyValue = options.apiKey;
+    this.basePath = (options.basePath ?? options.configuration?.basePath ?? BASE_PATH).replace(/\/+$/, "");
+    const f = options.fetchImpl ?? (typeof fetch !== "undefined" ? fetch : undefined);
+    if (!f) {
+      throw new Error("MudbaseQuery: no `fetch` available - pass `fetchImpl`");
+    }
+    this.fetchImpl = f;
+  }
+
+  /** Start a query against `collectionSlug` (the collection's `slug`, not its Mongo `_id`). */
+  from<T = MudbaseQueryDocument>(collectionSlug: string): MudbaseQueryBuilder<T> {
+    return new MudbaseQueryBuilder<T>(
+      this.projectId,
+      collectionSlug,
+      this.basePath,
+      this.tokenSource,
+      this.apiKeyValue,
+      this.configuration,
+      this.fetchImpl,
+    );
+  }
+}
+
+export class MudbaseQueryBuilder<T = MudbaseQueryDocument> {
+  private readonly plainFilter: Record<string, unknown> = {};
+  private readonly dottedFilter: Record<string, unknown> = {};
+  private readonly selectFields: string[] = [];
+  private readonly populateKeys: string[] = [];
+  // Ordered by field name (leading "-" stripped) so a repeated `.sort()` call on the same field
+  // replaces its earlier entry instead of duplicating it - see design note 2 above.
+  private readonly sortFields = new Map<string, string>();
+  private limitValue?: number;
+  private pageValue?: number;
+
+  constructor(
+    private readonly projectId: string,
+    private readonly collectionSlug: string,
+    private readonly basePath: string,
+    private readonly tokenSource: string | (() => string | Promise<string>) | undefined,
+    private readonly apiKeyValue: string | undefined,
+    private readonly configuration: Configuration | undefined,
+    private readonly fetchImpl: typeof fetch,
+  ) {}
+
+  /** `?fields=a,b,c` - whitelist-project which fields come back. */
+  select(...fields: string[]): this {
+    for (const field of fields) if (field && this.selectFields.indexOf(field) === -1) this.selectFields.push(field);
+    return this;
+  }
+
+  /**
+   * Equality filter. A dotted `field` (e.g. `"authorId.name"`) becomes its own deep/relationship
+   * top-level query key; a plain field name is merged into the `filter` JSON object. See design
+   * note 1 above for why the routing rule is exactly "does the name contain a dot," matching the
+   * server's own `RESERVED_LIST_QUERY_KEYS` + dotted-key convention.
+   */
+  eq(field: string, value: unknown): this {
+    if (field.includes(".")) {
+      this.dottedFilter[field] = value;
+    } else {
+      this.plainFilter[field] = value;
+    }
+    return this;
+  }
+
+  /**
+   * `?populate=authorId,comments` (or a dotted nested key like `"comments.authorId"`) - joins a
+   * declared relationship (or legacy reference field) onto each returned document.
+   */
+  populate(...keys: string[]): this {
+    for (const key of keys) if (key && this.populateKeys.indexOf(key) === -1) this.populateKeys.push(key);
+    return this;
+  }
+
+  /**
+   * `?sort=-createdAt,title` - accepts the same tokens the backend's `?sort=` parses, including
+   * a dotted relationship-field sort (e.g. `"authorId.name"`, `"-authorId.name"`). See design
+   * note 2 above for the append/replace-by-field semantics across repeated calls.
+   */
+  sort(...fields: string[]): this {
+    for (const field of fields) {
+      if (!field) continue;
+      const base = field.startsWith("-") ? field.slice(1) : field;
+      this.sortFields.delete(base);
+      this.sortFields.set(base, field);
+    }
+    return this;
+  }
+
+  /** Page size (server clamps to a max; see the API docs for the current bound). */
+  limit(n: number): this {
+    this.limitValue = n;
+    return this;
+  }
+
+  /** 1-based page number. */
+  page(n: number): this {
+    this.pageValue = n;
+    return this;
+  }
+
+  /**
+   * Compile the chain into the query-string params `GET .../data` accepts. Pure and
+   * network-free - the same params `execute()` sends, exposed separately so the
+   * query-compilation logic is directly unit-testable.
+   */
+  toQueryParams(): CompiledQueryParams {
+    const params: CompiledQueryParams = {};
+    if (this.pageValue !== undefined) params.page = this.pageValue;
+    if (this.limitValue !== undefined) params.limit = this.limitValue;
+    if (this.sortFields.size > 0) params.sort = [...this.sortFields.values()].join(",");
+    if (Object.keys(this.plainFilter).length > 0) params.filter = JSON.stringify(this.plainFilter);
+    if (this.selectFields.length > 0) params.fields = this.selectFields.join(",");
+    if (this.populateKeys.length > 0) params.populate = this.populateKeys.join(",");
+    for (const key of Object.keys(this.dottedFilter)) {
+      params[key] = this.dottedFilter[key] as string;
+    }
+    return params;
+  }
+
+  /**
+   * Run the query. Resolves to the same shape the generated `DataApi.listData()` resolves to -
+   * `{ data: [...], pagination: {...} }`. Auth (bearer token or API key) and base-path fallback
+   * mirror the generated `Configuration`'s own resolution exactly (see design note 6 above); only
+   * the query-string shape is hand-assembled, since it is the one part the generated client
+   * cannot fully express.
+   */
+  async execute(): Promise<MudbaseQueryResponse<T>> {
+    const url = `${this.basePath}/api/data/projects/${encodeURIComponent(this.projectId)}/collections/${encodeURIComponent(this.collectionSlug)}/data`;
+    const search = new URLSearchParams();
+    const compiled = this.toQueryParams();
+    for (const key of Object.keys(compiled)) {
+      const value = compiled[key];
+      if (value !== undefined) search.set(key, String(value));
+    }
+    const queryString = search.toString();
+
+    const res = await this.fetchImpl(queryString ? `${url}?${queryString}` : url, {
+      method: "GET",
+      headers: await this.authHeaders(),
+    });
+    const body = await this.parseJson(res);
+    if (!res.ok) {
+      throw new Error(this.errorMessage(body, `Mudbase query failed (${res.status})`));
+    }
+    return body as MudbaseQueryResponse<T>;
+  }
+
+  /** Alias for `.execute()` - reads better at a call site than the more literal name. */
+  get(): Promise<MudbaseQueryResponse<T>> {
+    return this.execute();
+  }
+
+  // --- internal helpers ------------------------------------------------------------
+
+  private async authHeaders(): Promise<Record<string, string>> {
+    const headers: Record<string, string> = { Accept: "application/json" };
+    const token = await this.resolveToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const apiKey = await this.resolveApiKey();
+    if (apiKey) {
+      headers["X-API-Key"] = apiKey;
+    }
+    return headers;
+  }
+
+  private async resolveToken(): Promise<string | undefined> {
+    const src = this.tokenSource;
+    if (typeof src === "string") return src;
+    if (typeof src === "function") return await src();
+    const at = this.configuration?.accessToken as
+      | string
+      | ((name?: string, scopes?: string[]) => string | Promise<string>)
+      | undefined;
+    if (typeof at === "string") return at;
+    if (typeof at === "function") return await at();
+    return undefined;
+  }
+
+  private async resolveApiKey(): Promise<string | undefined> {
+    if (this.apiKeyValue) return this.apiKeyValue;
+    const ak = this.configuration?.apiKey as
+      | string
+      | ((name: string) => string | Promise<string>)
+      | undefined;
+    if (typeof ak === "string") return ak;
+    if (typeof ak === "function") return await ak("X-API-Key");
+    return undefined;
+  }
+
+  private async parseJson(res: Response): Promise<any> {
+    const text = await res.text();
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { error: text };
+    }
+  }
+
+  private errorMessage(body: any, fallback: string): string {
+    if (body && typeof body.error === "string" && body.error) return body.error;
+    if (body && typeof body.message === "string" && body.message) return body.message;
+    return fallback;
+  }
+}

package/src/runtime.ts

@@ -4,7 +4,7 @@
  * 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). - 🏢 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.11
+ * The version of the OpenAPI document: 1.3.13
  * Contact: support@mudbase.dev
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).