@aerostack/sdk-node 0.7.6 → 0.7.8

package/src/_generated/apis/AuthenticationApi.ts

@@ -2,9 +2,9 @@
 /* eslint-disable */
 /**
  * Aerostack API
- * Aerostack Platform API - Unified access to database, authentication,  caching, queues, storage, and AI services. 
+ * Aerostack Platform API - Unified access to database, authentication, caching, queues, storage, and AI services. 
  *
- * The version of the OpenAPI document: 1.0.0
+ * The version of the OpenAPI document: 1.5.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).

package/src/_generated/apis/CacheApi.ts

@@ -2,9 +2,9 @@
 /* eslint-disable */
 /**
  * Aerostack API
- * Aerostack Platform API - Unified access to database, authentication,  caching, queues, storage, and AI services. 
+ * Aerostack Platform API - Unified access to database, authentication, caching, queues, storage, and AI services. 
  *
- * The version of the OpenAPI document: 1.0.0
+ * The version of the OpenAPI document: 1.5.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -15,35 +15,270 @@
 
 import * as runtime from '../runtime.js';
 import type {
+  CacheDeleteMany200Response,
+  CacheDeleteManyRequest,
+  CacheExpireRequest,
+  CacheFlush200Response,
+  CacheFlushRequest,
   CacheGet200Response,
+  CacheGetMany200Response,
+  CacheGetManyRequest,
   CacheGetRequest,
+  CacheIncrement200Response,
+  CacheIncrementRequest,
+  CacheKeys200Response,
+  CacheKeysRequest,
+  CacheListRequest,
+  CacheListResult,
   CacheSet200Response,
+  CacheSetMany200Response,
+  CacheSetManyRequest,
   CacheSetRequest,
 } from '../models/index.js';
 import {
+    CacheDeleteMany200ResponseFromJSON,
+    CacheDeleteMany200ResponseToJSON,
+    CacheDeleteManyRequestFromJSON,
+    CacheDeleteManyRequestToJSON,
+    CacheExpireRequestFromJSON,
+    CacheExpireRequestToJSON,
+    CacheFlush200ResponseFromJSON,
+    CacheFlush200ResponseToJSON,
+    CacheFlushRequestFromJSON,
+    CacheFlushRequestToJSON,
     CacheGet200ResponseFromJSON,
     CacheGet200ResponseToJSON,
+    CacheGetMany200ResponseFromJSON,
+    CacheGetMany200ResponseToJSON,
+    CacheGetManyRequestFromJSON,
+    CacheGetManyRequestToJSON,
     CacheGetRequestFromJSON,
     CacheGetRequestToJSON,
+    CacheIncrement200ResponseFromJSON,
+    CacheIncrement200ResponseToJSON,
+    CacheIncrementRequestFromJSON,
+    CacheIncrementRequestToJSON,
+    CacheKeys200ResponseFromJSON,
+    CacheKeys200ResponseToJSON,
+    CacheKeysRequestFromJSON,
+    CacheKeysRequestToJSON,
+    CacheListRequestFromJSON,
+    CacheListRequestToJSON,
+    CacheListResultFromJSON,
+    CacheListResultToJSON,
     CacheSet200ResponseFromJSON,
     CacheSet200ResponseToJSON,
+    CacheSetMany200ResponseFromJSON,
+    CacheSetMany200ResponseToJSON,
+    CacheSetManyRequestFromJSON,
+    CacheSetManyRequestToJSON,
     CacheSetRequestFromJSON,
     CacheSetRequestToJSON,
 } from '../models/index.js';
 
+export interface CacheDeleteRequest {
+    cacheGetRequest: CacheGetRequest;
+}
+
+export interface CacheDeleteManyOperationRequest {
+    cacheDeleteManyRequest: CacheDeleteManyRequest;
+}
+
+export interface CacheExpireOperationRequest {
+    cacheExpireRequest: CacheExpireRequest;
+}
+
+export interface CacheFlushOperationRequest {
+    cacheFlushRequest: CacheFlushRequest;
+}
+
 export interface CacheGetOperationRequest {
     cacheGetRequest: CacheGetRequest;
 }
 
+export interface CacheGetManyOperationRequest {
+    cacheGetManyRequest: CacheGetManyRequest;
+}
+
+export interface CacheIncrementOperationRequest {
+    cacheIncrementRequest: CacheIncrementRequest;
+}
+
+export interface CacheKeysOperationRequest {
+    cacheKeysRequest: CacheKeysRequest;
+}
+
+export interface CacheListOperationRequest {
+    cacheListRequest: CacheListRequest;
+}
+
 export interface CacheSetOperationRequest {
     cacheSetRequest: CacheSetRequest;
 }
 
+export interface CacheSetManyOperationRequest {
+    cacheSetManyRequest: CacheSetManyRequest;
+}
+
 /**
  * 
  */
 export class CacheApi extends runtime.BaseAPI {
 
+    /**
+     * Delete cached value
+     */
+    async cacheDeleteRaw(requestParameters: CacheDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheSet200Response>> {
+        if (requestParameters.cacheGetRequest === null || requestParameters.cacheGetRequest === undefined) {
+            throw new runtime.RequiredError('cacheGetRequest','Required parameter requestParameters.cacheGetRequest was null or undefined when calling cacheDelete.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/delete`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheGetRequestToJSON(requestParameters.cacheGetRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheSet200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Delete cached value
+     */
+    async cacheDelete(requestParameters: CacheDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheSet200Response> {
+        const response = await this.cacheDeleteRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Delete up to 500 keys in a single call.
+     * Delete multiple cached values in one request
+     */
+    async cacheDeleteManyRaw(requestParameters: CacheDeleteManyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheDeleteMany200Response>> {
+        if (requestParameters.cacheDeleteManyRequest === null || requestParameters.cacheDeleteManyRequest === undefined) {
+            throw new runtime.RequiredError('cacheDeleteManyRequest','Required parameter requestParameters.cacheDeleteManyRequest was null or undefined when calling cacheDeleteMany.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/deleteMany`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheDeleteManyRequestToJSON(requestParameters.cacheDeleteManyRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheDeleteMany200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Delete up to 500 keys in a single call.
+     * Delete multiple cached values in one request
+     */
+    async cacheDeleteMany(requestParameters: CacheDeleteManyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheDeleteMany200Response> {
+        const response = await this.cacheDeleteManyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Updates the expiration time of an existing key. Internally performs a get-then-put since KV has no native TTL-update operation. Note: not atomic — a concurrent write between get and put may be lost. 
+     * Update TTL of an existing cache key
+     */
+    async cacheExpireRaw(requestParameters: CacheExpireOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheSet200Response>> {
+        if (requestParameters.cacheExpireRequest === null || requestParameters.cacheExpireRequest === undefined) {
+            throw new runtime.RequiredError('cacheExpireRequest','Required parameter requestParameters.cacheExpireRequest was null or undefined when calling cacheExpire.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/expire`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheExpireRequestToJSON(requestParameters.cacheExpireRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheSet200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Updates the expiration time of an existing key. Internally performs a get-then-put since KV has no native TTL-update operation. Note: not atomic — a concurrent write between get and put may be lost. 
+     * Update TTL of an existing cache key
+     */
+    async cacheExpire(requestParameters: CacheExpireOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheSet200Response> {
+        const response = await this.cacheExpireRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Deletes all cache keys matching the given prefix (or all project keys if no prefix). This operation is irreversible. Hard cap of 10,000 keys per flush. Rate limited to 5 requests per minute. 
+     * Flush all keys matching a prefix
+     */
+    async cacheFlushRaw(requestParameters: CacheFlushOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheFlush200Response>> {
+        if (requestParameters.cacheFlushRequest === null || requestParameters.cacheFlushRequest === undefined) {
+            throw new runtime.RequiredError('cacheFlushRequest','Required parameter requestParameters.cacheFlushRequest was null or undefined when calling cacheFlush.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/flush`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheFlushRequestToJSON(requestParameters.cacheFlushRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheFlush200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Deletes all cache keys matching the given prefix (or all project keys if no prefix). This operation is irreversible. Hard cap of 10,000 keys per flush. Rate limited to 5 requests per minute. 
+     * Flush all keys matching a prefix
+     */
+    async cacheFlush(requestParameters: CacheFlushOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheFlush200Response> {
+        const response = await this.cacheFlushRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Get cached value
      */
@@ -81,6 +316,162 @@ export class CacheApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Fetch up to 100 keys in a single call. More efficient than sequential gets.
+     * Get multiple cached values in one request
+     */
+    async cacheGetManyRaw(requestParameters: CacheGetManyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheGetMany200Response>> {
+        if (requestParameters.cacheGetManyRequest === null || requestParameters.cacheGetManyRequest === undefined) {
+            throw new runtime.RequiredError('cacheGetManyRequest','Required parameter requestParameters.cacheGetManyRequest was null or undefined when calling cacheGetMany.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/getMany`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheGetManyRequestToJSON(requestParameters.cacheGetManyRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheGetMany200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Fetch up to 100 keys in a single call. More efficient than sequential gets.
+     * Get multiple cached values in one request
+     */
+    async cacheGetMany(requestParameters: CacheGetManyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheGetMany200Response> {
+        const response = await this.cacheGetManyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Increments a numeric cache value by the given amount (default 1). If the key does not exist, initializes it to `initialValue` (default 0) before incrementing. Uses read-modify-write — not atomic under high concurrency. Suitable for counters where occasional drift is acceptable (page views, likes). Not suitable for inventory or financial counters where exact accuracy is critical. 
+     * Atomically increment a numeric counter
+     */
+    async cacheIncrementRaw(requestParameters: CacheIncrementOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheIncrement200Response>> {
+        if (requestParameters.cacheIncrementRequest === null || requestParameters.cacheIncrementRequest === undefined) {
+            throw new runtime.RequiredError('cacheIncrementRequest','Required parameter requestParameters.cacheIncrementRequest was null or undefined when calling cacheIncrement.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/increment`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheIncrementRequestToJSON(requestParameters.cacheIncrementRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheIncrement200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Increments a numeric cache value by the given amount (default 1). If the key does not exist, initializes it to `initialValue` (default 0) before incrementing. Uses read-modify-write — not atomic under high concurrency. Suitable for counters where occasional drift is acceptable (page views, likes). Not suitable for inventory or financial counters where exact accuracy is critical. 
+     * Atomically increment a numeric counter
+     */
+    async cacheIncrement(requestParameters: CacheIncrementOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheIncrement200Response> {
+        const response = await this.cacheIncrementRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Auto-paginates internally and returns all matching keys in one response. Hard cap of 10,000 keys. For large keyspaces use `/cache/list` with cursors. 
+     * Get all keys matching prefix
+     */
+    async cacheKeysRaw(requestParameters: CacheKeysOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheKeys200Response>> {
+        if (requestParameters.cacheKeysRequest === null || requestParameters.cacheKeysRequest === undefined) {
+            throw new runtime.RequiredError('cacheKeysRequest','Required parameter requestParameters.cacheKeysRequest was null or undefined when calling cacheKeys.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/keys`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheKeysRequestToJSON(requestParameters.cacheKeysRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheKeys200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Auto-paginates internally and returns all matching keys in one response. Hard cap of 10,000 keys. For large keyspaces use `/cache/list` with cursors. 
+     * Get all keys matching prefix
+     */
+    async cacheKeys(requestParameters: CacheKeysOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheKeys200Response> {
+        const response = await this.cacheKeysRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Returns paginated list of cache keys matching an optional prefix. Keys are isolated per project — you only see keys belonging to your project. Use `cursor` from the response to fetch the next page. 
+     * List cache keys with prefix
+     */
+    async cacheListRaw(requestParameters: CacheListOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheListResult>> {
+        if (requestParameters.cacheListRequest === null || requestParameters.cacheListRequest === undefined) {
+            throw new runtime.RequiredError('cacheListRequest','Required parameter requestParameters.cacheListRequest was null or undefined when calling cacheList.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/list`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheListRequestToJSON(requestParameters.cacheListRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheListResultFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns paginated list of cache keys matching an optional prefix. Keys are isolated per project — you only see keys belonging to your project. Use `cursor` from the response to fetch the next page. 
+     * List cache keys with prefix
+     */
+    async cacheList(requestParameters: CacheListOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheListResult> {
+        const response = await this.cacheListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Set cached value
      */
@@ -118,4 +509,43 @@ export class CacheApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Store up to 100 key-value pairs in a single call.
+     * Set multiple cached values in one request
+     */
+    async cacheSetManyRaw(requestParameters: CacheSetManyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CacheSetMany200Response>> {
+        if (requestParameters.cacheSetManyRequest === null || requestParameters.cacheSetManyRequest === undefined) {
+            throw new runtime.RequiredError('cacheSetManyRequest','Required parameter requestParameters.cacheSetManyRequest was null or undefined when calling cacheSetMany.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/cache/setMany`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CacheSetManyRequestToJSON(requestParameters.cacheSetManyRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CacheSetMany200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Store up to 100 key-value pairs in a single call.
+     * Set multiple cached values in one request
+     */
+    async cacheSetMany(requestParameters: CacheSetManyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CacheSetMany200Response> {
+        const response = await this.cacheSetManyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
 }

package/src/_generated/apis/DatabaseApi.ts

@@ -2,9 +2,9 @@
 /* eslint-disable */
 /**
  * Aerostack API
- * Aerostack Platform API - Unified access to database, authentication,  caching, queues, storage, and AI services. 
+ * Aerostack Platform API - Unified access to database, authentication, caching, queues, storage, and AI services. 
  *
- * The version of the OpenAPI document: 1.0.0
+ * The version of the OpenAPI document: 1.5.0
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -15,11 +15,17 @@
 
 import * as runtime from '../runtime.js';
 import type {
+  DbBatchRequest,
+  DbBatchResult,
   DbQueryRequest,
   DbQueryResult,
   ErrorResponse,
 } from '../models/index.js';
 import {
+    DbBatchRequestFromJSON,
+    DbBatchRequestToJSON,
+    DbBatchResultFromJSON,
+    DbBatchResultToJSON,
     DbQueryRequestFromJSON,
     DbQueryRequestToJSON,
     DbQueryResultFromJSON,
@@ -28,6 +34,10 @@ import {
     ErrorResponseToJSON,
 } from '../models/index.js';
 
+export interface DbBatchOperationRequest {
+    dbBatchRequest: DbBatchRequest;
+}
+
 export interface DbQueryOperationRequest {
     dbQueryRequest: DbQueryRequest;
     xRequestID?: string;
@@ -39,6 +49,45 @@ export interface DbQueryOperationRequest {
  */
 export class DatabaseApi extends runtime.BaseAPI {
 
+    /**
+     * Run up to 25 SQL queries in a single request. Each query runs through the same sanitization and project-isolation pipeline as `/db/query`. Failures are partial — successful queries still return results even if others fail. Batching is more efficient than sequential individual calls. 
+     * Execute multiple SQL queries in batch
+     */
+    async dbBatchRaw(requestParameters: DbBatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DbBatchResult>> {
+        if (requestParameters.dbBatchRequest === null || requestParameters.dbBatchRequest === undefined) {
+            throw new runtime.RequiredError('dbBatchRequest','Required parameter requestParameters.dbBatchRequest was null or undefined when calling dbBatch.');
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-Aerostack-Key"] = this.configuration.apiKey("X-Aerostack-Key"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/db/batch`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: DbBatchRequestToJSON(requestParameters.dbBatchRequest),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => DbBatchResultFromJSON(jsonValue));
+    }
+
+    /**
+     * Run up to 25 SQL queries in a single request. Each query runs through the same sanitization and project-isolation pipeline as `/db/query`. Failures are partial — successful queries still return results even if others fail. Batching is more efficient than sequential individual calls. 
+     * Execute multiple SQL queries in batch
+     */
+    async dbBatch(requestParameters: DbBatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DbBatchResult> {
+        const response = await this.dbBatchRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Run a SQL query against your project database
      * Execute SQL query