@stagware/nocodb-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1640 @@
+// src/index.ts
+import fs from "fs";
+import path from "path";
+import { ofetch, FetchError } from "ofetch";
+
+// src/errors.ts
+var NocoDBError = class extends Error {
+  /**
+   * Creates a new NocoDBError instance.
+   * 
+   * @param message - Human-readable error message
+   * @param code - Machine-readable error code for programmatic handling
+   * @param statusCode - HTTP status code if applicable
+   * @param data - Additional error data (e.g., response body, validation details)
+   * 
+   * @example
+   * ```typescript
+   * throw new NocoDBError('Operation failed', 'OPERATION_FAILED', 500, { details: 'Server error' });
+   * ```
+   */
+  constructor(message, code, statusCode, data) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.data = data;
+    this.name = "NocoDBError";
+  }
+};
+var NetworkError = class extends NocoDBError {
+  /**
+   * Creates a new NetworkError instance.
+   * 
+   * @param message - Human-readable error message
+   * @param cause - The underlying error that caused this network error
+   * 
+   * @example
+   * ```typescript
+   * try {
+   *   await fetch('https://api.example.com');
+   * } catch (err) {
+   *   throw new NetworkError('Failed to connect to server', err);
+   * }
+   * ```
+   */
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR");
+    this.cause = cause;
+  }
+};
+var AuthenticationError = class extends NocoDBError {
+  /**
+   * Creates a new AuthenticationError instance.
+   * 
+   * @param message - Human-readable error message
+   * @param statusCode - HTTP status code (typically 401 or 403)
+   * @param data - Additional error data from the server response
+   * 
+   * @example
+   * ```typescript
+   * throw new AuthenticationError('Invalid API token', 401, { error: 'Token expired' });
+   * ```
+   */
+  constructor(message, statusCode, data) {
+    super(message, "AUTH_ERROR", statusCode, data);
+  }
+};
+var ValidationError = class extends NocoDBError {
+  /**
+   * Creates a new ValidationError instance.
+   * 
+   * @param message - Human-readable error message
+   * @param fieldErrors - Optional map of field names to validation error messages
+   * 
+   * @example
+   * ```typescript
+   * throw new ValidationError('Invalid request data', {
+   *   email: ['Must be a valid email address'],
+   *   age: ['Must be a positive number']
+   * });
+   * ```
+   */
+  constructor(message, fieldErrors) {
+    super(message, "VALIDATION_ERROR", 400);
+    this.fieldErrors = fieldErrors;
+  }
+};
+var NotFoundError = class extends NocoDBError {
+  /**
+   * Creates a new NotFoundError instance.
+   * 
+   * @param resource - The type of resource that was not found (e.g., 'Base', 'Table', 'Row')
+   * @param id - The identifier of the resource that was not found
+   * 
+   * @example
+   * ```typescript
+   * throw new NotFoundError('Table', 'tbl_abc123');
+   * // Error message: "Table not found: tbl_abc123"
+   * ```
+   */
+  constructor(resource, id) {
+    super(`${resource} not found: ${id}`, "NOT_FOUND", 404);
+  }
+};
+var ConflictError = class extends NocoDBError {
+  /**
+   * Creates a new ConflictError instance.
+   * 
+   * @param message - Human-readable error message
+   * @param data - Additional error data from the server response
+   * 
+   * @example
+   * ```typescript
+   * throw new ConflictError('Row already exists with this unique key', { key: 'email', value: 'user@example.com' });
+   * ```
+   */
+  constructor(message, data) {
+    super(message, "CONFLICT", 409, data);
+  }
+};
+
+// src/index.ts
+var NocoClient = class {
+  baseUrl;
+  headers;
+  timeoutMs;
+  retryOptions;
+  /**
+   * Creates a new NocoClient instance.
+   * 
+   * @param options - Client configuration options
+   */
+  constructor(options) {
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.headers = { ...options.headers ?? {} };
+    this.timeoutMs = options.timeoutMs;
+    this.retryOptions = options.retry;
+  }
+  /**
+   * Sets a default header that will be included in all requests.
+   * 
+   * @param name - Header name
+   * @param value - Header value
+   * 
+   * @example
+   * ```typescript
+   * client.setHeader('xc-token', 'new-api-token');
+   * ```
+   */
+  setHeader(name, value) {
+    this.headers[name] = value;
+  }
+  /**
+   * Removes a default header.
+   * 
+   * @param name - Header name to remove
+   * 
+   * @example
+   * ```typescript
+   * client.removeHeader('xc-token');
+   * ```
+   */
+  removeHeader(name) {
+    delete this.headers[name];
+  }
+  /**
+   * Makes an HTTP request to the NocoDB API.
+   * 
+   * Automatically handles error mapping, retry logic, and timeout handling.
+   * Throws typed errors (AuthenticationError, NotFoundError, etc.) based on
+   * HTTP status codes.
+   * 
+   * @template T - Expected response type
+   * @param method - HTTP method (GET, POST, PATCH, DELETE, etc.)
+   * @param path - API endpoint path (e.g., '/api/v2/meta/bases')
+   * @param options - Request options (headers, query params, body, etc.)
+   * @returns Promise resolving to the typed response
+   * @throws {AuthenticationError} When authentication fails (401, 403)
+   * @throws {NotFoundError} When resource is not found (404)
+   * @throws {ConflictError} When a conflict occurs (409)
+   * @throws {ValidationError} When request validation fails (400)
+   * @throws {NetworkError} For network-level errors or other HTTP errors
+   * 
+   * @example
+   * ```typescript
+   * const bases = await client.request<ListResponse<Base>>(
+   *   'GET',
+   *   '/api/v2/meta/bases'
+   * );
+   * 
+   * const newBase = await client.request<Base>(
+   *   'POST',
+   *   '/api/v2/meta/bases',
+   *   { body: { title: 'My Base' } }
+   * );
+   * ```
+   */
+  async request(method, path2, options = {}) {
+    const urlPath = path2.startsWith("/") ? path2 : `/${path2}`;
+    const headers = { ...this.headers, ...options.headers ?? {} };
+    const retry = options.retry ?? this.retryOptions;
+    const isVerbose = process.argv.includes("--verbose");
+    let attemptCount = 0;
+    const startTime = Date.now();
+    try {
+      const result = await ofetch(urlPath, {
+        baseURL: this.baseUrl,
+        method,
+        headers,
+        query: options.query,
+        body: options.body,
+        timeout: options.timeoutMs ?? this.timeoutMs,
+        retry: retry?.retry,
+        retryDelay: retry?.retryDelay,
+        retryStatusCodes: retry?.retryStatusCodes,
+        onRequest: () => {
+          attemptCount++;
+          if (isVerbose && attemptCount > 1) {
+            console.error(`[Retry] Attempt ${attemptCount} for ${method} ${urlPath}`);
+          }
+        }
+      });
+      if (isVerbose) {
+        const duration = Date.now() - startTime;
+        console.error(`[Timing] ${method} ${urlPath} completed in ${duration}ms`);
+      }
+      return result;
+    } catch (error) {
+      if (isVerbose) {
+        const duration = Date.now() - startTime;
+        console.error(`[Timing] ${method} ${urlPath} failed after ${duration}ms`);
+        if (attemptCount > 1) {
+          console.error(`[Retry] All ${attemptCount} attempts failed for ${method} ${urlPath}`);
+        }
+      }
+      if (error instanceof FetchError) {
+        const statusCode = error.response?.status;
+        const responseData = error.data;
+        const errorMessage = responseData?.msg || responseData?.message || responseData?.error || error.message || "Request failed";
+        if (statusCode === 401 || statusCode === 403) {
+          throw new AuthenticationError(errorMessage, statusCode, responseData);
+        }
+        if (statusCode === 404) {
+          throw new NotFoundError("Resource", errorMessage);
+        }
+        if (statusCode === 409) {
+          throw new ConflictError(errorMessage, responseData);
+        }
+        if (statusCode === 400) {
+          throw new ValidationError(errorMessage);
+        }
+        throw new NetworkError(
+          `HTTP ${statusCode}: ${errorMessage}`,
+          error
+        );
+      }
+      if (error instanceof Error) {
+        throw new NetworkError(error.message, error);
+      }
+      throw new NetworkError("Unknown error occurred", error);
+    }
+  }
+  /**
+   * Fetches all pages of a paginated list endpoint and returns the combined results.
+   *
+   * Automatically handles offset-based pagination by making sequential requests
+   * until all rows are retrieved. Useful for large datasets where a single request
+   * would only return a partial result.
+   *
+   * @template T - The type of items in the list
+   * @param method - HTTP method (typically 'GET')
+   * @param path - API endpoint path
+   * @param options - Request options (query params, headers, etc.)
+   * @param pageSize - Number of items per page (default: 1000)
+   * @returns Promise resolving to a ListResponse containing all items
+   *
+   * @example
+   * ```typescript
+   * // Fetch all rows from a table
+   * const allRows = await client.fetchAllPages<Row>(
+   *   'GET',
+   *   '/api/v2/tables/tbl123/records'
+   * );
+   * console.log(`Total: ${allRows.list.length} rows`);
+   *
+   * // Fetch all with a filter
+   * const filtered = await client.fetchAllPages<Row>(
+   *   'GET',
+   *   '/api/v2/tables/tbl123/records',
+   *   { query: { where: '(Status,eq,Active)' } }
+   * );
+   * ```
+   */
+  async fetchAllPages(method, path2, options = {}, pageSize = 1e3) {
+    const first = await this.request(method, path2, {
+      ...options,
+      query: { ...options.query, limit: pageSize, offset: 0 }
+    });
+    const totalRows = first.pageInfo?.totalRows ?? 0;
+    if (first.list.length === 0 || first.list.length >= totalRows || first.list.length < pageSize) {
+      return first;
+    }
+    const allItems = [...first.list];
+    let offset = first.list.length;
+    while (offset < totalRows) {
+      const page = await this.request(method, path2, {
+        ...options,
+        query: { ...options.query, limit: pageSize, offset }
+      });
+      if (page.list.length === 0) break;
+      allItems.push(...page.list);
+      offset += page.list.length;
+    }
+    return {
+      list: allItems,
+      pageInfo: {
+        totalRows: allItems.length,
+        page: 1,
+        pageSize: allItems.length,
+        isFirstPage: true,
+        isLastPage: true
+      }
+    };
+  }
+};
+var MetaApi = class {
+  /**
+   * Creates a new MetaApi instance.
+   * 
+   * @param client - NocoClient instance for making HTTP requests
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lists all bases accessible to the authenticated user.
+   * 
+   * @returns Promise resolving to paginated list of bases
+   * @throws {AuthenticationError} If authentication fails
+   * @throws {NetworkError} If the request fails
+   * 
+   * @example
+   * ```typescript
+   * const response = await metaApi.listBases();
+   * console.log(`Found ${response.pageInfo.totalRows} bases`);
+   * ```
+   */
+  listBases() {
+    return this.client.request("GET", "/api/v2/meta/bases");
+  }
+  /**
+   * Creates a new base.
+   * 
+   * @param body - Base properties (title is required)
+   * @returns Promise resolving to the created base
+   * @throws {ValidationError} If the request data is invalid
+   * @throws {AuthenticationError} If authentication fails
+   * 
+   * @example
+   * ```typescript
+   * const base = await metaApi.createBase({ title: 'My Project' });
+   * console.log(`Created base: ${base.id}`);
+   * ```
+   */
+  createBase(body) {
+    return this.client.request("POST", "/api/v2/meta/bases", { body });
+  }
+  /**
+   * Gets detailed information about a specific base.
+   * 
+   * @param baseId - ID of the base to retrieve
+   * @returns Promise resolving to the base details
+   * @throws {NotFoundError} If the base doesn't exist
+   * @throws {AuthenticationError} If authentication fails
+   * 
+   * @example
+   * ```typescript
+   * const base = await metaApi.getBase('base_abc123');
+   * console.log(`Base title: ${base.title}`);
+   * ```
+   */
+  getBase(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}`);
+  }
+  /**
+   * Gets base information including metadata.
+   * 
+   * @param baseId - ID of the base
+   * @returns Promise resolving to the base info
+   * @throws {NotFoundError} If the base doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const info = await metaApi.getBaseInfo('base_abc123');
+   * ```
+   */
+  getBaseInfo(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/info`);
+  }
+  /**
+   * Updates a base's properties.
+   * 
+   * @param baseId - ID of the base to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated base
+   * @throws {NotFoundError} If the base doesn't exist
+   * @throws {ValidationError} If the update data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const updated = await metaApi.updateBase('base_abc123', { title: 'New Title' });
+   * ```
+   */
+  updateBase(baseId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/bases/${baseId}`, { body });
+  }
+  /**
+   * Deletes a base permanently.
+   * 
+   * @param baseId - ID of the base to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the base doesn't exist
+   * @throws {AuthenticationError} If authentication fails
+   * 
+   * @example
+   * ```typescript
+   * await metaApi.deleteBase('base_abc123');
+   * console.log('Base deleted');
+   * ```
+   */
+  deleteBase(baseId) {
+    return this.client.request("DELETE", `/api/v2/meta/bases/${baseId}`);
+  }
+  // ── Sources (Data Sources) ─────────────────────────────────────────
+  /**
+   * Lists all data sources for a base.
+   *
+   * @param baseId - ID of the base
+   * @returns Promise resolving to paginated list of sources
+   * @throws {NotFoundError} If the base doesn't exist
+   */
+  listSources(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/sources`);
+  }
+  /**
+   * Creates a new data source in a base.
+   *
+   * @param baseId - ID of the base
+   * @param body - Source properties (alias, type, config, etc.)
+   * @returns Promise resolving to the created source
+   * @throws {ValidationError} If the request data is invalid
+   */
+  createSource(baseId, body) {
+    return this.client.request("POST", `/api/v2/meta/bases/${baseId}/sources`, { body });
+  }
+  /**
+   * Gets detailed information about a specific data source.
+   *
+   * @param baseId - ID of the base
+   * @param sourceId - ID of the source to retrieve
+   * @returns Promise resolving to the source details
+   * @throws {NotFoundError} If the source doesn't exist
+   */
+  getSource(baseId, sourceId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/sources/${sourceId}`);
+  }
+  /**
+   * Updates a data source's properties.
+   *
+   * @param baseId - ID of the base
+   * @param sourceId - ID of the source to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated source
+   * @throws {NotFoundError} If the source doesn't exist
+   */
+  updateSource(baseId, sourceId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/bases/${baseId}/sources/${sourceId}`, { body });
+  }
+  /**
+   * Deletes a data source permanently.
+   *
+   * @param baseId - ID of the base
+   * @param sourceId - ID of the source to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the source doesn't exist
+   */
+  deleteSource(baseId, sourceId) {
+    return this.client.request("DELETE", `/api/v2/meta/bases/${baseId}/sources/${sourceId}`);
+  }
+  /**
+   * Lists all tables in a base.
+   * 
+   * @param baseId - ID of the base
+   * @returns Promise resolving to paginated list of tables
+   * @throws {NotFoundError} If the base doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const response = await metaApi.listTables('base_abc123');
+   * for (const table of response.list) {
+   *   console.log(`Table: ${table.title}`);
+   * }
+   * ```
+   */
+  listTables(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/tables`);
+  }
+  /**
+   * Creates a new table in a base.
+   * 
+   * @param baseId - ID of the base
+   * @param body - Table properties (title and table_name are required)
+   * @returns Promise resolving to the created table
+   * @throws {ValidationError} If the request data is invalid
+   * @throws {ConflictError} If a table with the same name already exists
+   * 
+   * @example
+   * ```typescript
+   * const table = await metaApi.createTable('base_abc123', {
+   *   title: 'Users',
+   *   table_name: 'users'
+   * });
+   * ```
+   */
+  createTable(baseId, body) {
+    return this.client.request("POST", `/api/v2/meta/bases/${baseId}/tables`, { body });
+  }
+  /**
+   * Gets detailed information about a specific table.
+   * 
+   * @param tableId - ID of the table to retrieve
+   * @returns Promise resolving to the table details including columns
+   * @throws {NotFoundError} If the table doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const table = await metaApi.getTable('tbl_abc123');
+   * console.log(`Table has ${table.columns?.length} columns`);
+   * ```
+   */
+  getTable(tableId) {
+    return this.client.request("GET", `/api/v2/meta/tables/${tableId}`);
+  }
+  /**
+   * Updates a table's properties.
+   * 
+   * @param tableId - ID of the table to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated table
+   * @throws {NotFoundError} If the table doesn't exist
+   * @throws {ValidationError} If the update data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const updated = await metaApi.updateTable('tbl_abc123', { title: 'New Title' });
+   * ```
+   */
+  updateTable(tableId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/tables/${tableId}`, { body });
+  }
+  /**
+   * Deletes a table permanently.
+   * 
+   * @param tableId - ID of the table to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the table doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * await metaApi.deleteTable('tbl_abc123');
+   * ```
+   */
+  deleteTable(tableId) {
+    return this.client.request("DELETE", `/api/v2/meta/tables/${tableId}`);
+  }
+  /**
+   * Lists all views for a table.
+   * 
+   * @param tableId - ID of the table
+   * @returns Promise resolving to paginated list of views
+   * @throws {NotFoundError} If the table doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const response = await metaApi.listViews('tbl_abc123');
+   * for (const view of response.list) {
+   *   console.log(`View: ${view.title} (${view.type})`);
+   * }
+   * ```
+   */
+  listViews(tableId) {
+    return this.client.request("GET", `/api/v2/meta/tables/${tableId}/views`);
+  }
+  /**
+   * Creates a new view for a table.
+   * 
+   * @param tableId - ID of the table
+   * @param body - View properties (title and type are required)
+   * @returns Promise resolving to the created view
+   * @throws {ValidationError} If the request data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const view = await metaApi.createView('tbl_abc123', {
+   *   title: 'Active Users',
+   *   type: 'grid'
+   * });
+   * ```
+   */
+  createView(tableId, body) {
+    return this.client.request("POST", `/api/v2/meta/tables/${tableId}/views`, { body });
+  }
+  /**
+   * Gets detailed information about a specific view.
+   * 
+   * @param viewId - ID of the view to retrieve
+   * @returns Promise resolving to the view details
+   * @throws {NotFoundError} If the view doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const view = await metaApi.getView('vw_abc123');
+   * ```
+   */
+  getView(viewId) {
+    return this.client.request("GET", `/api/v2/meta/views/${viewId}`);
+  }
+  /**
+   * Updates a view's properties.
+   * 
+   * @param viewId - ID of the view to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated view
+   * @throws {NotFoundError} If the view doesn't exist
+   * @throws {ValidationError} If the update data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const updated = await metaApi.updateView('vw_abc123', { title: 'New Title' });
+   * ```
+   */
+  updateView(viewId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/views/${viewId}`, { body });
+  }
+  /**
+   * Deletes a view permanently.
+   * 
+   * @param viewId - ID of the view to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the view doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * await metaApi.deleteView('vw_abc123');
+   * ```
+   */
+  deleteView(viewId) {
+    return this.client.request("DELETE", `/api/v2/meta/views/${viewId}`);
+  }
+  /**
+   * Lists all filters for a view.
+   * 
+   * @param viewId - ID of the view
+   * @returns Promise resolving to paginated list of filters
+   * @throws {NotFoundError} If the view doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const response = await metaApi.listViewFilters('vw_abc123');
+   * ```
+   */
+  listViewFilters(viewId) {
+    return this.client.request("GET", `/api/v2/meta/views/${viewId}/filters`);
+  }
+  /**
+   * Creates a new filter for a view.
+   * 
+   * @param viewId - ID of the view
+   * @param body - Filter properties
+   * @returns Promise resolving to the created filter
+   * @throws {ValidationError} If the request data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const filter = await metaApi.createViewFilter('vw_abc123', {
+   *   fk_column_id: 'col_xyz',
+   *   comparison_op: 'eq',
+   *   value: 'active'
+   * });
+   * ```
+   */
+  createViewFilter(viewId, body) {
+    return this.client.request("POST", `/api/v2/meta/views/${viewId}/filters`, { body });
+  }
+  /**
+   * Gets detailed information about a specific filter.
+   * 
+   * @param filterId - ID of the filter to retrieve
+   * @returns Promise resolving to the filter details
+   * @throws {NotFoundError} If the filter doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const filter = await metaApi.getFilter('flt_abc123');
+   * ```
+   */
+  getFilter(filterId) {
+    return this.client.request("GET", `/api/v2/meta/filters/${filterId}`);
+  }
+  /**
+   * Updates a filter's properties.
+   * 
+   * @param filterId - ID of the filter to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated filter
+   * @throws {NotFoundError} If the filter doesn't exist
+   * @throws {ValidationError} If the update data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const updated = await metaApi.updateFilter('flt_abc123', { value: 'inactive' });
+   * ```
+   */
+  updateFilter(filterId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/filters/${filterId}`, { body });
+  }
+  /**
+   * Deletes a filter permanently.
+   * 
+   * @param filterId - ID of the filter to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the filter doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * await metaApi.deleteFilter('flt_abc123');
+   * ```
+   */
+  deleteFilter(filterId) {
+    return this.client.request("DELETE", `/api/v2/meta/filters/${filterId}`);
+  }
+  /**
+   * Lists all sorts for a view.
+   * 
+   * @param viewId - ID of the view
+   * @returns Promise resolving to paginated list of sorts
+   * @throws {NotFoundError} If the view doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const response = await metaApi.listViewSorts('vw_abc123');
+   * ```
+   */
+  listViewSorts(viewId) {
+    return this.client.request("GET", `/api/v2/meta/views/${viewId}/sorts`);
+  }
+  /**
+   * Creates a new sort for a view.
+   * 
+   * @param viewId - ID of the view
+   * @param body - Sort properties (fk_column_id and direction are required)
+   * @returns Promise resolving to the created sort
+   * @throws {ValidationError} If the request data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const sort = await metaApi.createViewSort('vw_abc123', {
+   *   fk_column_id: 'col_xyz',
+   *   direction: 'asc'
+   * });
+   * ```
+   */
+  createViewSort(viewId, body) {
+    return this.client.request("POST", `/api/v2/meta/views/${viewId}/sorts`, { body });
+  }
+  /**
+   * Gets detailed information about a specific sort.
+   * 
+   * @param sortId - ID of the sort to retrieve
+   * @returns Promise resolving to the sort details
+   * @throws {NotFoundError} If the sort doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const sort = await metaApi.getSort('srt_abc123');
+   * ```
+   */
+  getSort(sortId) {
+    return this.client.request("GET", `/api/v2/meta/sorts/${sortId}`);
+  }
+  /**
+   * Updates a sort's properties.
+   * 
+   * @param sortId - ID of the sort to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated sort
+   * @throws {NotFoundError} If the sort doesn't exist
+   * @throws {ValidationError} If the update data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const updated = await metaApi.updateSort('srt_abc123', { direction: 'desc' });
+   * ```
+   */
+  updateSort(sortId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/sorts/${sortId}`, { body });
+  }
+  /**
+   * Deletes a sort permanently.
+   * 
+   * @param sortId - ID of the sort to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the sort doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * await metaApi.deleteSort('srt_abc123');
+   * ```
+   */
+  deleteSort(sortId) {
+    return this.client.request("DELETE", `/api/v2/meta/sorts/${sortId}`);
+  }
+  /**
+   * Lists all columns for a table.
+   * 
+   * @param tableId - ID of the table
+   * @returns Promise resolving to paginated list of columns
+   * @throws {NotFoundError} If the table doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const response = await metaApi.listColumns('tbl_abc123');
+   * for (const col of response.list) {
+   *   console.log(`Column: ${col.title} (${col.uidt})`);
+   * }
+   * ```
+   */
+  listColumns(tableId) {
+    return this.client.request("GET", `/api/v2/meta/tables/${tableId}/columns`);
+  }
+  /**
+   * Creates a new column in a table.
+   * 
+   * @param tableId - ID of the table
+   * @param body - Column properties (title, column_name, and uidt are required)
+   * @returns Promise resolving to the created column
+   * @throws {ValidationError} If the request data is invalid
+   * @throws {ConflictError} If a column with the same name already exists
+   * 
+   * @example
+   * ```typescript
+   * const column = await metaApi.createColumn('tbl_abc123', {
+   *   title: 'Email',
+   *   column_name: 'email',
+   *   uidt: 'Email'
+   * });
+   * ```
+   */
+  createColumn(tableId, body) {
+    return this.client.request("POST", `/api/v2/meta/tables/${tableId}/columns`, { body });
+  }
+  /**
+   * Gets detailed information about a specific column.
+   * 
+   * @param columnId - ID of the column to retrieve
+   * @returns Promise resolving to the column details
+   * @throws {NotFoundError} If the column doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const column = await metaApi.getColumn('col_abc123');
+   * ```
+   */
+  getColumn(columnId) {
+    return this.client.request("GET", `/api/v2/meta/columns/${columnId}`);
+  }
+  /**
+   * Updates a column's properties.
+   * 
+   * @param columnId - ID of the column to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated column
+   * @throws {NotFoundError} If the column doesn't exist
+   * @throws {ValidationError} If the update data is invalid
+   * 
+   * @example
+   * ```typescript
+   * const updated = await metaApi.updateColumn('col_abc123', { title: 'New Title' });
+   * ```
+   */
+  updateColumn(columnId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/columns/${columnId}`, { body });
+  }
+  /**
+   * Deletes a column permanently.
+   * 
+   * @param columnId - ID of the column to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the column doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * await metaApi.deleteColumn('col_abc123');
+   * ```
+   */
+  deleteColumn(columnId) {
+    return this.client.request("DELETE", `/api/v2/meta/columns/${columnId}`);
+  }
+  // ── Hooks (Webhooks) ──────────────────────────────────────────────
+  /**
+   * Lists all hooks for a table.
+   *
+   * @param tableId - ID of the table
+   * @returns Promise resolving to paginated list of hooks
+   * @throws {NotFoundError} If the table doesn't exist
+   */
+  listHooks(tableId) {
+    return this.client.request("GET", `/api/v2/meta/tables/${tableId}/hooks`);
+  }
+  /**
+   * Creates a new hook (webhook) for a table.
+   *
+   * @param tableId - ID of the table
+   * @param body - Hook properties
+   * @returns Promise resolving to the created hook
+   * @throws {ValidationError} If the request data is invalid
+   */
+  createHook(tableId, body) {
+    return this.client.request("POST", `/api/v2/meta/tables/${tableId}/hooks`, { body });
+  }
+  /**
+   * Gets detailed information about a specific hook.
+   *
+   * @param hookId - ID of the hook to retrieve
+   * @returns Promise resolving to the hook details
+   * @throws {NotFoundError} If the hook doesn't exist
+   */
+  getHook(hookId) {
+    return this.client.request("GET", `/api/v2/meta/hooks/${hookId}`);
+  }
+  /**
+   * Updates a hook's properties.
+   *
+   * @param hookId - ID of the hook to update
+   * @param body - Properties to update
+   * @returns Promise resolving to the updated hook
+   * @throws {NotFoundError} If the hook doesn't exist
+   */
+  updateHook(hookId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/hooks/${hookId}`, { body });
+  }
+  /**
+   * Deletes a hook permanently.
+   *
+   * @param hookId - ID of the hook to delete
+   * @returns Promise that resolves when deletion is complete
+   * @throws {NotFoundError} If the hook doesn't exist
+   */
+  deleteHook(hookId) {
+    return this.client.request("DELETE", `/api/v2/meta/hooks/${hookId}`);
+  }
+  /**
+   * Tests a hook by triggering a sample notification.
+   *
+   * @param hookId - ID of the hook to test
+   * @param body - Optional test payload
+   * @returns Promise resolving to the test result
+   * @throws {NotFoundError} If the hook doesn't exist
+   */
+  testHook(hookId, body) {
+    return this.client.request("POST", `/api/v2/meta/hooks/${hookId}/test`, body ? { body } : {});
+  }
+  // ── API Tokens ────────────────────────────────────────────────────
+  /**
+   * Lists all API tokens for a base.
+   *
+   * @param baseId - ID of the base
+   * @returns Promise resolving to a list of API tokens
+   */
+  listTokens(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/api-tokens`);
+  }
+  /**
+   * Creates a new API token for a base.
+   *
+   * @param baseId - ID of the base
+   * @param body - Token properties (description is recommended)
+   * @returns Promise resolving to the created token (includes the token string)
+   */
+  createToken(baseId, body) {
+    return this.client.request("POST", `/api/v2/meta/bases/${baseId}/api-tokens`, { body });
+  }
+  /**
+   * Deletes an API token from a base.
+   *
+   * @param baseId - ID of the base
+   * @param tokenId - ID of the token to delete
+   * @returns Promise that resolves when deletion is complete
+   */
+  deleteToken(baseId, tokenId) {
+    return this.client.request("DELETE", `/api/v2/meta/bases/${baseId}/api-tokens/${tokenId}`);
+  }
+  // ── Base Users (Collaborators) ────────────────────────────────────
+  /**
+   * Lists all users (collaborators) for a base.
+   *
+   * @param baseId - ID of the base
+   * @returns Promise resolving to a list of base users
+   * @throws {NotFoundError} If the base doesn't exist
+   */
+  listBaseUsers(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/users`);
+  }
+  /**
+   * Invites a user to a base.
+   *
+   * @param baseId - ID of the base
+   * @param body - User properties (email and roles are required)
+   * @returns Promise resolving to the invite result
+   * @throws {ValidationError} If the request data is invalid
+   */
+  inviteBaseUser(baseId, body) {
+    return this.client.request("POST", `/api/v2/meta/bases/${baseId}/users`, { body });
+  }
+  /**
+   * Updates a user's role in a base.
+   *
+   * @param baseId - ID of the base
+   * @param userId - ID of the user to update
+   * @param body - Properties to update (typically roles)
+   * @returns Promise resolving to the updated user
+   */
+  updateBaseUser(baseId, userId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/bases/${baseId}/users/${userId}`, { body });
+  }
+  /**
+   * Removes a user from a base.
+   *
+   * @param baseId - ID of the base
+   * @param userId - ID of the user to remove
+   * @returns Promise that resolves when removal is complete
+   */
+  removeBaseUser(baseId, userId) {
+    return this.client.request("DELETE", `/api/v2/meta/bases/${baseId}/users/${userId}`);
+  }
+  // ── Comments ─────────────────────────────────────────────────────
+  /**
+   * Lists comments for a specific row.
+   *
+   * @param tableId - ID of the table (fk_model_id)
+   * @param rowId - ID of the row
+   * @returns Promise resolving to a list of comments
+   */
+  listComments(tableId, rowId) {
+    return this.client.request("GET", "/api/v2/meta/comments", {
+      query: { fk_model_id: tableId, row_id: rowId }
+    });
+  }
+  /**
+   * Creates a comment on a row.
+   *
+   * @param body - Comment properties (fk_model_id, row_id, comment are required)
+   * @returns Promise resolving to the created comment
+   */
+  createComment(body) {
+    return this.client.request("POST", "/api/v2/meta/comments", { body });
+  }
+  /**
+   * Updates a comment.
+   *
+   * @param commentId - ID of the comment to update
+   * @param body - Properties to update (typically comment text)
+   * @returns Promise resolving to the updated comment
+   */
+  updateComment(commentId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/comment/${commentId}`, { body });
+  }
+  /**
+   * Deletes a comment.
+   *
+   * @param commentId - ID of the comment to delete
+   * @returns Promise that resolves when deletion is complete
+   */
+  deleteComment(commentId) {
+    return this.client.request("DELETE", `/api/v2/meta/comment/${commentId}`);
+  }
+  // ── Shared Views ────────────────────────────────────────────────
+  /**
+   * Lists shared views for a table.
+   *
+   * @param tableId - ID of the table
+   * @returns Promise resolving to a list of shared views
+   */
+  listSharedViews(tableId) {
+    return this.client.request("GET", `/api/v2/meta/tables/${tableId}/share`);
+  }
+  /**
+   * Creates a shared view (public link) for a view.
+   *
+   * @param viewId - ID of the view to share
+   * @param body - Optional shared view properties (password, meta)
+   * @returns Promise resolving to the created shared view
+   */
+  createSharedView(viewId, body) {
+    return this.client.request("POST", `/api/v2/meta/views/${viewId}/share`, body ? { body } : {});
+  }
+  /**
+   * Updates a shared view's properties.
+   *
+   * @param viewId - ID of the view whose share to update
+   * @param body - Properties to update (password, meta)
+   * @returns Promise resolving to the updated shared view
+   */
+  updateSharedView(viewId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/views/${viewId}/share`, { body });
+  }
+  /**
+   * Deletes a shared view (removes public link).
+   *
+   * @param viewId - ID of the view whose share to delete
+   * @returns Promise that resolves when deletion is complete
+   */
+  deleteSharedView(viewId) {
+    return this.client.request("DELETE", `/api/v2/meta/views/${viewId}/share`);
+  }
+  // ── Shared Base ─────────────────────────────────────────────────
+  /**
+   * Gets shared base info (uuid, url, roles).
+   *
+   * @param baseId - ID of the base
+   * @returns Promise resolving to the shared base info
+   */
+  getSharedBase(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/shared`);
+  }
+  /**
+   * Creates a shared base (enables public sharing).
+   *
+   * @param baseId - ID of the base
+   * @param body - Shared base properties (roles, password)
+   * @returns Promise resolving to the created shared base
+   */
+  createSharedBase(baseId, body) {
+    return this.client.request("POST", `/api/v2/meta/bases/${baseId}/shared`, body ? { body } : {});
+  }
+  /**
+   * Updates a shared base's properties.
+   *
+   * @param baseId - ID of the base
+   * @param body - Properties to update (roles, password)
+   * @returns Promise resolving to the updated shared base
+   */
+  updateSharedBase(baseId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/bases/${baseId}/shared`, { body });
+  }
+  /**
+   * Disables shared base (removes public sharing).
+   *
+   * @param baseId - ID of the base
+   * @returns Promise that resolves when sharing is disabled
+   */
+  deleteSharedBase(baseId) {
+    return this.client.request("DELETE", `/api/v2/meta/bases/${baseId}/shared`);
+  }
+  // ── View-Type-Specific Endpoints ────────────────────────────────
+  /**
+   * Creates a grid view for a table.
+   *
+   * @param tableId - ID of the table
+   * @param body - View properties (title is required)
+   * @returns Promise resolving to the created view
+   */
+  createGridView(tableId, body) {
+    return this.client.request("POST", `/api/v2/meta/tables/${tableId}/grids`, { body });
+  }
+  /**
+   * Creates a form view for a table.
+   *
+   * @param tableId - ID of the table
+   * @param body - View properties (title is required)
+   * @returns Promise resolving to the created view
+   */
+  createFormView(tableId, body) {
+    return this.client.request("POST", `/api/v2/meta/tables/${tableId}/forms`, { body });
+  }
+  /**
+   * Creates a gallery view for a table.
+   *
+   * @param tableId - ID of the table
+   * @param body - View properties (title is required)
+   * @returns Promise resolving to the created view
+   */
+  createGalleryView(tableId, body) {
+    return this.client.request("POST", `/api/v2/meta/tables/${tableId}/galleries`, { body });
+  }
+  /**
+   * Creates a kanban view for a table.
+   *
+   * @param tableId - ID of the table
+   * @param body - View properties (title is required)
+   * @returns Promise resolving to the created view
+   */
+  createKanbanView(tableId, body) {
+    return this.client.request("POST", `/api/v2/meta/tables/${tableId}/kanbans`, { body });
+  }
+  /**
+   * Gets form view-specific configuration.
+   *
+   * @param formViewId - ID of the form view
+   * @returns Promise resolving to the form view config
+   */
+  getFormView(formViewId) {
+    return this.client.request("GET", `/api/v2/meta/forms/${formViewId}`);
+  }
+  /**
+   * Updates form view-specific configuration.
+   *
+   * @param formViewId - ID of the form view
+   * @param body - Form-specific properties to update
+   * @returns Promise resolving to the updated form view config
+   */
+  updateFormView(formViewId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/forms/${formViewId}`, { body });
+  }
+  /**
+   * Gets gallery view-specific configuration.
+   *
+   * @param galleryViewId - ID of the gallery view
+   * @returns Promise resolving to the gallery view config
+   */
+  getGalleryView(galleryViewId) {
+    return this.client.request("GET", `/api/v2/meta/galleries/${galleryViewId}`);
+  }
+  /**
+   * Updates gallery view-specific configuration.
+   *
+   * @param galleryViewId - ID of the gallery view
+   * @param body - Gallery-specific properties to update
+   * @returns Promise resolving to the updated gallery view config
+   */
+  updateGalleryView(galleryViewId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/galleries/${galleryViewId}`, { body });
+  }
+  /**
+   * Gets kanban view-specific configuration.
+   *
+   * @param kanbanViewId - ID of the kanban view
+   * @returns Promise resolving to the kanban view config
+   */
+  getKanbanView(kanbanViewId) {
+    return this.client.request("GET", `/api/v2/meta/kanbans/${kanbanViewId}`);
+  }
+  /**
+   * Updates kanban view-specific configuration.
+   *
+   * @param kanbanViewId - ID of the kanban view
+   * @param body - Kanban-specific properties to update
+   * @returns Promise resolving to the updated kanban view config
+   */
+  updateKanbanView(kanbanViewId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/kanbans/${kanbanViewId}`, { body });
+  }
+  /**
+   * Updates grid view-specific configuration.
+   *
+   * @param gridViewId - ID of the grid view
+   * @param body - Grid-specific properties to update
+   * @returns Promise resolving to the updated grid view config
+   */
+  updateGridView(gridViewId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/grids/${gridViewId}`, { body });
+  }
+  /**
+   * Lists columns for a view (field visibility/order settings).
+   *
+   * @param viewId - ID of the view
+   * @returns Promise resolving to a list of view columns
+   */
+  listViewColumns(viewId) {
+    return this.client.request("GET", `/api/v2/meta/views/${viewId}/columns`);
+  }
+  // ── Filter Children (Nested Filter Groups) ─────────────────────────
+  /**
+   * Lists child filters of a filter group.
+   *
+   * @param filterGroupId - ID of the parent filter group
+   * @returns Promise resolving to a list of child filters
+   */
+  listFilterChildren(filterGroupId) {
+    return this.client.request("GET", `/api/v2/meta/filters/${filterGroupId}/children`);
+  }
+  // ── Hook Filters ───────────────────────────────────────────────────
+  /**
+   * Lists filters for a hook (webhook).
+   *
+   * @param hookId - ID of the hook
+   * @returns Promise resolving to a list of hook filters
+   */
+  listHookFilters(hookId) {
+    return this.client.request("GET", `/api/v2/meta/hooks/${hookId}/filters`);
+  }
+  /**
+   * Creates a filter for a hook (webhook).
+   *
+   * @param hookId - ID of the hook
+   * @param body - Filter properties
+   * @returns Promise resolving to the created filter
+   */
+  createHookFilter(hookId, body) {
+    return this.client.request("POST", `/api/v2/meta/hooks/${hookId}/filters`, { body });
+  }
+  // ── Column: Set Primary ────────────────────────────────────────────
+  /**
+   * Sets a column as the primary/display column for its table.
+   *
+   * @param columnId - ID of the column to set as primary
+   * @returns Promise resolving when the column is set as primary
+   */
+  setColumnPrimary(columnId) {
+    return this.client.request("POST", `/api/v2/meta/columns/${columnId}/primary`);
+  }
+  // ── Duplicate Operations ───────────────────────────────────────────
+  /**
+   * Duplicates a base.
+   *
+   * @param baseId - ID of the base to duplicate
+   * @param options - Optional duplicate options (excludeData, excludeViews, excludeHooks)
+   * @returns Promise resolving to the duplicate operation result
+   */
+  duplicateBase(baseId, options) {
+    return this.client.request("POST", `/api/v2/meta/duplicate/${baseId}`, options ? { body: { options } } : {});
+  }
+  /**
+   * Duplicates a base source.
+   *
+   * @param baseId - ID of the base
+   * @param sourceId - ID of the source to duplicate
+   * @param options - Optional duplicate options
+   * @returns Promise resolving to the duplicate operation result
+   */
+  duplicateSource(baseId, sourceId, options) {
+    return this.client.request("POST", `/api/v2/meta/duplicate/${baseId}/${sourceId}`, options ? { body: { options } } : {});
+  }
+  /**
+   * Duplicates a table within a base.
+   *
+   * @param baseId - ID of the base
+   * @param tableId - ID of the table to duplicate
+   * @param options - Optional duplicate options
+   * @returns Promise resolving to the duplicate operation result
+   */
+  duplicateTable(baseId, tableId, options) {
+    return this.client.request("POST", `/api/v2/meta/duplicate/${baseId}/table/${tableId}`, options ? { body: { options } } : {});
+  }
+  // ── Visibility Rules (UI ACL) ──────────────────────────────────────
+  /**
+   * Gets view visibility rules for a base (UI ACL).
+   *
+   * @param baseId - ID of the base
+   * @returns Promise resolving to the visibility rules
+   */
+  getVisibilityRules(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/visibility-rules`);
+  }
+  /**
+   * Sets view visibility rules for a base (UI ACL).
+   *
+   * @param baseId - ID of the base
+   * @param body - Visibility rules to set
+   * @returns Promise resolving when rules are set
+   */
+  setVisibilityRules(baseId, body) {
+    return this.client.request("POST", `/api/v2/meta/bases/${baseId}/visibility-rules`, { body });
+  }
+  // ── App Info ───────────────────────────────────────────────────────
+  /**
+   * Gets NocoDB server application info (version, etc.).
+   *
+   * @returns Promise resolving to the app info
+   */
+  getAppInfo() {
+    return this.client.request("GET", "/api/v2/meta/nocodb/info");
+  }
+  // ── Cloud Workspaces (☁ cloud-only) ──────────────────────────────
+  /**
+   * Lists all workspaces (☁ cloud-only).
+   *
+   * @returns Promise resolving to paginated list of workspaces
+   * @throws {NetworkError} If the instance doesn't support workspaces (self-hosted)
+   */
+  listWorkspaces() {
+    return this.client.request("GET", "/api/v2/meta/workspaces");
+  }
+  /**
+   * Gets a workspace by ID (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @returns Promise resolving to the workspace details and user count
+   * @throws {NotFoundError} If the workspace doesn't exist
+   */
+  getWorkspace(workspaceId) {
+    return this.client.request("GET", `/api/v2/meta/workspaces/${workspaceId}`);
+  }
+  /**
+   * Creates a new workspace (☁ cloud-only).
+   *
+   * @param body - Workspace properties (title is required)
+   * @returns Promise resolving to the created workspace
+   * @throws {ValidationError} If the request data is invalid
+   */
+  createWorkspace(body) {
+    return this.client.request("POST", "/api/v2/meta/workspaces", { body });
+  }
+  /**
+   * Updates a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace to update
+   * @param body - Properties to update
+   * @returns Promise resolving when the update is complete
+   */
+  updateWorkspace(workspaceId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/workspaces/${workspaceId}`, { body });
+  }
+  /**
+   * Deletes a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace to delete
+   * @returns Promise resolving when deletion is complete
+   */
+  deleteWorkspace(workspaceId) {
+    return this.client.request("DELETE", `/api/v2/meta/workspaces/${workspaceId}`);
+  }
+  /**
+   * Lists users in a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @returns Promise resolving to a list of workspace users
+   */
+  listWorkspaceUsers(workspaceId) {
+    return this.client.request("GET", `/api/v2/meta/workspaces/${workspaceId}/users`);
+  }
+  /**
+   * Gets a specific user in a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @param userId - ID of the user
+   * @returns Promise resolving to the workspace user details
+   */
+  getWorkspaceUser(workspaceId, userId) {
+    return this.client.request("GET", `/api/v2/meta/workspaces/${workspaceId}/users/${userId}`);
+  }
+  /**
+   * Invites a user to a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @param body - Invite properties (email and roles are required)
+   * @returns Promise resolving to the invite result
+   */
+  inviteWorkspaceUser(workspaceId, body) {
+    return this.client.request("POST", `/api/v2/meta/workspaces/${workspaceId}/invitations`, { body });
+  }
+  /**
+   * Updates a user's role in a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @param userId - ID of the user to update
+   * @param body - Properties to update (typically roles)
+   * @returns Promise resolving when the update is complete
+   */
+  updateWorkspaceUser(workspaceId, userId, body) {
+    return this.client.request("PATCH", `/api/v2/meta/workspaces/${workspaceId}/users/${userId}`, { body });
+  }
+  /**
+   * Removes a user from a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @param userId - ID of the user to remove
+   * @returns Promise resolving when removal is complete
+   */
+  deleteWorkspaceUser(workspaceId, userId) {
+    return this.client.request("DELETE", `/api/v2/meta/workspaces/${workspaceId}/users/${userId}`);
+  }
+  /**
+   * Lists bases in a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @returns Promise resolving to a paginated list of bases
+   */
+  listWorkspaceBases(workspaceId) {
+    return this.client.request("GET", `/api/v2/meta/workspaces/${workspaceId}/bases`);
+  }
+  /**
+   * Creates a base in a workspace (☁ cloud-only).
+   *
+   * @param workspaceId - ID of the workspace
+   * @param body - Base properties (title is required)
+   * @returns Promise resolving to the created base
+   */
+  createWorkspaceBase(workspaceId, body) {
+    return this.client.request("POST", `/api/v2/meta/workspaces/${workspaceId}/bases`, { body });
+  }
+  /**
+   * Gets the Swagger/OpenAPI specification for a base.
+   * 
+   * Returns the complete API documentation for all tables and operations
+   * in the specified base.
+   * 
+   * @param baseId - ID of the base
+   * @returns Promise resolving to the Swagger document
+   * @throws {NotFoundError} If the base doesn't exist
+   * 
+   * @example
+   * ```typescript
+   * const swagger = await metaApi.getBaseSwagger('base_abc123');
+   * console.log(`API version: ${swagger.info.version}`);
+   * ```
+   */
+  getBaseSwagger(baseId) {
+    return this.client.request("GET", `/api/v2/meta/bases/${baseId}/swagger.json`);
+  }
+  /**
+   * Uploads a file attachment.
+   * 
+   * Uploads a file from the local filesystem to NocoDB storage.
+   * The returned data can be used in attachment column fields.
+   * 
+   * @param filePath - Path to the file to upload
+   * @returns Promise resolving to upload response with file metadata
+   * @throws {ValidationError} If the file doesn't exist or is invalid
+   * @throws {NetworkError} If the upload fails
+   * 
+   * @example
+   * ```typescript
+   * const result = await metaApi.uploadAttachment('/path/to/image.png');
+   * // Use result in an attachment column
+   * ```
+   */
+  async uploadAttachment(filePath) {
+    const fileName = path.basename(filePath);
+    const fileContent = await fs.promises.readFile(filePath);
+    const boundary = `----nocodb-${Date.now()}`;
+    const header = `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${fileName}"\r
+Content-Type: application/octet-stream\r
+\r
+`;
+    const footer = `\r
+--${boundary}--\r
+`;
+    const body = Buffer.concat([Buffer.from(header), fileContent, Buffer.from(footer)]);
+    return this.client.request("POST", "/api/v2/storage/upload", {
+      body,
+      headers: { "content-type": `multipart/form-data; boundary=${boundary}` }
+    });
+  }
+};
+var DataApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List linked records for a specific record and link field.
+   *
+   * @param tableId - ID of the table containing the record
+   * @param linkFieldId - ID of the link field (column)
+   * @param recordId - ID of the record to get links for
+   * @param query - Optional query parameters for filtering/pagination
+   * @returns Paginated list of linked rows
+   *
+   * @example
+   * ```typescript
+   * const links = await dataApi.listLinks('tbl123', 'col456', 'rec789');
+   * console.log(`Found ${links.pageInfo.totalRows} linked records`);
+   * ```
+   */
+  listLinks(tableId, linkFieldId, recordId, query) {
+    return this.client.request("GET", `/api/v2/tables/${tableId}/links/${linkFieldId}/records/${recordId}`, { query });
+  }
+  /**
+   * Link records together via a link field.
+   *
+   * @param tableId - ID of the table containing the record
+   * @param linkFieldId - ID of the link field (column)
+   * @param recordId - ID of the record to link from
+   * @param body - Array of record IDs or objects to link
+   * @returns Success response
+   *
+   * @example
+   * ```typescript
+   * await dataApi.linkRecords('tbl123', 'col456', 'rec789', [{ Id: 'rec999' }]);
+   * ```
+   */
+  linkRecords(tableId, linkFieldId, recordId, body) {
+    return this.client.request("POST", `/api/v2/tables/${tableId}/links/${linkFieldId}/records/${recordId}`, { body });
+  }
+  /**
+   * Unlink records from a link field.
+   *
+   * @param tableId - ID of the table containing the record
+   * @param linkFieldId - ID of the link field (column)
+   * @param recordId - ID of the record to unlink from
+   * @param body - Array of record IDs or objects to unlink
+   * @returns Success response
+   *
+   * @example
+   * ```typescript
+   * await dataApi.unlinkRecords('tbl123', 'col456', 'rec789', [{ Id: 'rec999' }]);
+   * ```
+   */
+  unlinkRecords(tableId, linkFieldId, recordId, body) {
+    return this.client.request("DELETE", `/api/v2/tables/${tableId}/links/${linkFieldId}/records/${recordId}`, { body });
+  }
+};
+function normalizeBaseUrl(input) {
+  return input.replace(/\/+$/, "");
+}
+function parseHeader(input) {
+  const idx = input.indexOf(":");
+  if (idx === -1) {
+    throw new Error(`Invalid header '${input}'. Use 'Name: Value'.`);
+  }
+  const name = input.slice(0, idx).trim();
+  const value = input.slice(idx + 1).trim();
+  if (!name || !value) {
+    throw new Error(`Invalid header '${input}'. Use 'Name: Value'.`);
+  }
+  return [name, value];
+}
+export {
+  AuthenticationError,
+  ConflictError,
+  DataApi,
+  MetaApi,
+  NetworkError,
+  NocoClient,
+  NocoDBError,
+  NotFoundError,
+  ValidationError,
+  normalizeBaseUrl,
+  parseHeader
+};