@centrali-io/centrali-sdk 2.2.1 → 2.2.3

package/README.md

@@ -31,13 +31,9 @@ const product = await centrali.createRecord('Product', {
 
 console.log('Created product:', product.data);
 
-// Invoke a compute function
-const result = await centrali.invokeFunction('calculate-discount', {
-  productId: product.id,
-  couponCode: 'SAVE20'
-});
-
-console.log('Discount result:', result.data);
+// Search for records
+const results = await centrali.search('Awesome');
+console.log('Found:', results.data.totalHits, 'results');
 ```
 
 ## Authentication
@@ -73,6 +69,8 @@ const centrali = new CentraliSDK({
 - ✅ **Automatic authentication** and token management
 - ✅ **Records management** - Create, read, update, delete records
 - ✅ **Query operations** - Powerful data querying with filters and sorting
+- ✅ **Smart Queries** - Execute reusable, predefined queries
+- ✅ **Full-text search** - Search records across structures with Meilisearch
 - ✅ **Realtime events** - Subscribe to record changes via SSE
 - ✅ **Compute functions** - Execute serverless functions
 - ✅ **File uploads** - Upload files to Centrali storage
@@ -97,9 +95,20 @@ await centrali.updateRecord('StructureName', 'record-id', {
   field1: 'new value'
 });
 
-// Delete a record
+// Delete a record (soft delete - can be restored)
 await centrali.deleteRecord('StructureName', 'record-id');
 
+// Hard delete a record (permanent - cannot be restored)
+await centrali.deleteRecord('StructureName', 'record-id', { hard: true });
+
+// Restore a soft-deleted record
+await centrali.restoreRecord('StructureName', 'record-id');
+
+// Query archived (soft-deleted) records
+const archived = await centrali.queryRecords('StructureName', {
+  includeArchived: true
+});
+
 // Query records
 const products = await centrali.queryRecords('Product', {
   filter: 'inStock = true AND price < 100',
@@ -108,6 +117,59 @@ const products = await centrali.queryRecords('Product', {
 });
 ```
 
+### Smart Queries
+
+Smart queries are reusable, predefined queries that are created in the Centrali console and can be executed programmatically via the SDK. Pagination (limit/skip) is defined in the query definition itself.
+
+```typescript
+// List all smart queries in the workspace
+const allQueries = await centrali.smartQueries.listAll();
+
+// List smart queries for a specific structure
+const employeeQueries = await centrali.smartQueries.list('employee');
+
+// Get a smart query by name
+const query = await centrali.smartQueries.getByName('employee', 'Active Employees');
+console.log('Query ID:', query.data.id);
+
+// Execute a smart query
+const results = await centrali.smartQueries.execute('employee', query.data.id);
+console.log('Found:', results.data.length, 'employees');
+```
+
+### Search
+
+Perform full-text search across workspace records using Meilisearch:
+
+```typescript
+// Basic search
+const results = await centrali.search('customer email');
+console.log('Found:', results.data.totalHits, 'results');
+results.data.hits.forEach(hit => {
+  console.log(hit.id, hit.structureSlug);
+});
+
+// Search with structure filter
+const userResults = await centrali.search('john', {
+  structures: 'users'
+});
+
+// Search multiple structures with limit
+const multiResults = await centrali.search('active', {
+  structures: ['users', 'orders'],
+  limit: 50
+});
+```
+
+#### Search Response
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `hits` | `SearchHit[]` | Array of matching records |
+| `totalHits` | `number` | Estimated total matches |
+| `processingTimeMs` | `number` | Search time in milliseconds |
+| `query` | `string` | The original search query |
+
 ### Realtime Events
 
 Subscribe to record changes in real-time using Server-Sent Events (SSE):
@@ -206,13 +268,15 @@ const realtime = new RealtimeManager(
 );
 ```
 
-### Compute Functions
+### Compute Functions (via Triggers)
 
 ```typescript
-// Execute a function
-const result = await centrali.invokeFunction('myFunction', {
-  data: 'your-input-data'
+// Invoke an on-demand trigger to execute a compute function
+const job = await centrali.triggers.invoke('trigger-id', {
+  payload: { data: 'your-input-data' }
 });
+
+console.log('Job queued:', job.data);
 ```
 
 ### File Uploads

package/dist/index.js

@@ -18,7 +18,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CentraliSDK = exports.TriggersManager = exports.RealtimeManager = void 0;
+exports.CentraliSDK = exports.SmartQueriesManager = exports.TriggersManager = exports.RealtimeManager = void 0;
 exports.getApiUrl = getApiUrl;
 exports.getAuthUrl = getAuthUrl;
 exports.getRealtimeUrl = getRealtimeUrl;
@@ -27,6 +27,13 @@ exports.getRecordApiPath = getRecordApiPath;
 exports.getFileUploadApiPath = getFileUploadApiPath;
 exports.getFunctionTriggersApiPath = getFunctionTriggersApiPath;
 exports.getFunctionTriggerExecuteApiPath = getFunctionTriggerExecuteApiPath;
+exports.getFunctionTriggerPauseApiPath = getFunctionTriggerPauseApiPath;
+exports.getFunctionTriggerResumeApiPath = getFunctionTriggerResumeApiPath;
+exports.getSmartQueriesApiPath = getSmartQueriesApiPath;
+exports.getSmartQueriesStructureApiPath = getSmartQueriesStructureApiPath;
+exports.getSmartQueryByNameApiPath = getSmartQueryByNameApiPath;
+exports.getSmartQueryExecuteApiPath = getSmartQueryExecuteApiPath;
+exports.getSearchApiPath = getSearchApiPath;
 const axios_1 = __importDefault(require("axios"));
 const qs_1 = __importDefault(require("qs"));
 const eventsource_1 = require("eventsource");
@@ -332,6 +339,49 @@ function getFunctionTriggersApiPath(workspaceId, triggerId) {
 function getFunctionTriggerExecuteApiPath(workspaceId, triggerId) {
     return `data/workspace/${workspaceId}/api/v1/function-triggers/${triggerId}/execute`;
 }
+/**
+ * Generate Function Trigger pause API URL PATH.
+ */
+function getFunctionTriggerPauseApiPath(workspaceId, triggerId) {
+    return `data/workspace/${workspaceId}/api/v1/function-triggers/${triggerId}/pause`;
+}
+/**
+ * Generate Function Trigger resume API URL PATH.
+ */
+function getFunctionTriggerResumeApiPath(workspaceId, triggerId) {
+    return `data/workspace/${workspaceId}/api/v1/function-triggers/${triggerId}/resume`;
+}
+/**
+ * Generate Smart Queries base API URL PATH for workspace-level operations.
+ */
+function getSmartQueriesApiPath(workspaceId) {
+    return `data/workspace/${workspaceId}/api/v1/smart-queries`;
+}
+/**
+ * Generate Smart Queries API URL PATH for structure-level operations.
+ */
+function getSmartQueriesStructureApiPath(workspaceId, structureSlug, queryId) {
+    const basePath = `data/workspace/${workspaceId}/api/v1/smart-queries/slug/${structureSlug}`;
+    return queryId ? `${basePath}/${queryId}` : basePath;
+}
+/**
+ * Generate Smart Query by name API URL PATH.
+ */
+function getSmartQueryByNameApiPath(workspaceId, structureSlug, name) {
+    return `data/workspace/${workspaceId}/api/v1/smart-queries/slug/${structureSlug}/name/${encodeURIComponent(name)}`;
+}
+/**
+ * Generate Smart Query execute API URL PATH.
+ */
+function getSmartQueryExecuteApiPath(workspaceId, structureSlug, queryId) {
+    return `data/workspace/${workspaceId}/api/v1/smart-queries/slug/${structureSlug}/execute/${queryId}`;
+}
+/**
+ * Generate Search API URL PATH.
+ */
+function getSearchApiPath(workspaceId) {
+    return `search/workspace/${workspaceId}/api/v1/records/search`;
+}
 // =====================================================
 // Triggers Manager
 // =====================================================
@@ -442,8 +492,177 @@ class TriggersManager {
         const params = Object.assign(Object.assign({}, queryParams), { executionType: 'on-demand' });
         return this.requestFn('GET', path, null, params);
     }
+    /**
+     * Pause a function trigger.
+     *
+     * Pauses an event-driven or scheduled trigger to temporarily disable it from firing.
+     * When paused, the trigger will not execute until resumed.
+     *
+     * For scheduled triggers, this also pauses the underlying scheduler job.
+     *
+     * @param triggerId - The ID of the trigger to pause
+     * @returns The updated trigger with enabled = false
+     *
+     * @example
+     * ```ts
+     * // Pause a trigger
+     * const result = await client.triggers.pauseTrigger('trigger-id');
+     * console.log('Trigger paused:', result.data.enabled === false);
+     * ```
+     */
+    pauseTrigger(triggerId) {
+        const path = getFunctionTriggerPauseApiPath(this.workspaceId, triggerId);
+        return this.requestFn('PATCH', path, {});
+    }
+    /**
+     * Resume a paused function trigger.
+     *
+     * Resumes a paused event-driven or scheduled trigger to re-enable it.
+     * Once resumed, the trigger will start firing again on matching events or schedules.
+     *
+     * For scheduled triggers, this also resumes the underlying scheduler job.
+     *
+     * @param triggerId - The ID of the trigger to resume
+     * @returns The updated trigger with enabled = true
+     *
+     * @example
+     * ```ts
+     * // Resume a paused trigger
+     * const result = await client.triggers.resumeTrigger('trigger-id');
+     * console.log('Trigger resumed:', result.data.enabled === true);
+     * ```
+     */
+    resumeTrigger(triggerId) {
+        const path = getFunctionTriggerResumeApiPath(this.workspaceId, triggerId);
+        return this.requestFn('PATCH', path, {});
+    }
 }
 exports.TriggersManager = TriggersManager;
+// =====================================================
+// Smart Queries Manager
+// =====================================================
+/**
+ * SmartQueriesManager provides methods for listing and executing smart queries.
+ * Smart queries are reusable, parameterized queries defined in the console
+ * that can be executed programmatically via the SDK.
+ * Access via `client.smartQueries`.
+ *
+ * Usage:
+ * ```ts
+ * // List smart queries for a structure
+ * const queries = await client.smartQueries.list('employee');
+ *
+ * // Execute a smart query by ID
+ * const results = await client.smartQueries.execute('employee', 'query-uuid');
+ *
+ * // Get a smart query by name
+ * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+ * ```
+ */
+class SmartQueriesManager {
+    constructor(workspaceId, requestFn) {
+        this.workspaceId = workspaceId;
+        this.requestFn = requestFn;
+    }
+    /**
+     * List all smart queries in the workspace.
+     *
+     * @param options - Optional list parameters (pagination, search, etc.)
+     * @returns List of smart queries with pagination metadata
+     *
+     * @example
+     * ```ts
+     * // List all smart queries
+     * const queries = await client.smartQueries.listAll();
+     *
+     * // With pagination
+     * const queries = await client.smartQueries.listAll({ page: 1, limit: 20 });
+     * ```
+     */
+    listAll(options) {
+        const path = getSmartQueriesApiPath(this.workspaceId);
+        return this.requestFn('GET', path, null, options);
+    }
+    /**
+     * List smart queries for a specific structure.
+     *
+     * @param structureSlug - The structure's record slug (e.g., "employee")
+     * @param options - Optional list parameters (pagination, search, etc.)
+     * @returns List of smart queries for the structure
+     *
+     * @example
+     * ```ts
+     * // List queries for employee structure
+     * const queries = await client.smartQueries.list('employee');
+     *
+     * // With pagination and search
+     * const queries = await client.smartQueries.list('employee', {
+     *   page: 1,
+     *   limit: 10,
+     *   search: 'active'
+     * });
+     * ```
+     */
+    list(structureSlug, options) {
+        const path = getSmartQueriesStructureApiPath(this.workspaceId, structureSlug);
+        return this.requestFn('GET', path, null, options);
+    }
+    /**
+     * Get a smart query by ID.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @returns The smart query details
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.get('employee', 'query-uuid');
+     * console.log('Query name:', query.data.name);
+     * ```
+     */
+    get(structureSlug, queryId) {
+        const path = getSmartQueriesStructureApiPath(this.workspaceId, structureSlug, queryId);
+        return this.requestFn('GET', path);
+    }
+    /**
+     * Get a smart query by name.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param name - The smart query name
+     * @returns The smart query details
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+     * console.log('Query ID:', query.data.id);
+     * ```
+     */
+    getByName(structureSlug, name) {
+        const path = getSmartQueryByNameApiPath(this.workspaceId, structureSlug, name);
+        return this.requestFn('GET', path);
+    }
+    /**
+     * Execute a smart query and return results.
+     *
+     * Note: Pagination (limit/skip) is defined in the query definition itself,
+     * not at execution time.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @returns Query results
+     *
+     * @example
+     * ```ts
+     * const results = await client.smartQueries.execute('employee', 'query-uuid');
+     * console.log('Found:', results.data.length, 'records');
+     * ```
+     */
+    execute(structureSlug, queryId) {
+        const path = getSmartQueryExecuteApiPath(this.workspaceId, structureSlug, queryId);
+        return this.requestFn('GET', path);
+    }
+}
+exports.SmartQueriesManager = SmartQueriesManager;
 /**
  * Main Centrali SDK client.
  */
@@ -452,6 +671,7 @@ class CentraliSDK {
         this.token = null;
         this._realtime = null;
         this._triggers = null;
+        this._smartQueries = null;
         this.options = options;
         this.token = options.token || null;
         const apiUrl = getApiUrl(options.baseUrl);
@@ -537,6 +757,31 @@ class CentraliSDK {
         }
         return this._triggers;
     }
+    /**
+     * Smart Queries namespace for listing and executing smart queries.
+     *
+     * Usage:
+     * ```ts
+     * // List all smart queries in workspace
+     * const allQueries = await client.smartQueries.listAll();
+     *
+     * // List smart queries for a structure
+     * const queries = await client.smartQueries.list('employee');
+     *
+     * // Get a smart query by name
+     * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+     *
+     * // Execute a smart query
+     * const results = await client.smartQueries.execute('employee', query.data.id);
+     * console.log('Found:', results.data.length, 'records');
+     * ```
+     */
+    get smartQueries() {
+        if (!this._smartQueries) {
+            this._smartQueries = new SmartQueriesManager(this.options.workspaceId, this.request.bind(this));
+        }
+        return this._smartQueries;
+    }
     /**
      * Manually set or update the bearer token for subsequent requests.
      */
@@ -570,6 +815,10 @@ class CentraliSDK {
             if (Array.isArray(resp.data)) {
                 return { data: resp.data };
             }
+            // Handle { result } responses (smart queries and some other endpoints)
+            if ('result' in resp.data && !('data' in resp.data)) {
+                return { data: resp.data.result };
+            }
             // Handle objects that don't have a data property (legacy endpoints)
             if (!('data' in resp.data)) {
                 return { data: resp.data };
@@ -607,10 +856,16 @@ class CentraliSDK {
         const path = getRecordApiPath(this.options.workspaceId, recordSlug, id);
         return this.request('PUT', path, Object.assign({}, updates));
     }
-    /** Delete a record by ID. */
-    deleteRecord(recordSlug, id) {
+    /** Delete a record by ID (soft delete by default, can be restored). */
+    deleteRecord(recordSlug, id, options) {
         const path = getRecordApiPath(this.options.workspaceId, recordSlug, id);
-        return this.request('DELETE', path);
+        const queryParams = (options === null || options === void 0 ? void 0 : options.hard) ? { hard: 'true' } : undefined;
+        return this.request('DELETE', path, null, queryParams);
+    }
+    /** Restore a soft-deleted record by ID. */
+    restoreRecord(recordSlug, id) {
+        const path = getRecordApiPath(this.options.workspaceId, recordSlug, id) + '/restore';
+        return this.request('POST', path);
     }
     // ------------------ Storage API Methods ------------------
     /** Upload a file to the storage service. */
@@ -630,6 +885,47 @@ class CentraliSDK {
             });
         });
     }
+    // ------------------ Search API Methods ------------------
+    /**
+     * Search records across the workspace using full-text search.
+     *
+     * @param query - The search query string
+     * @param options - Optional search parameters
+     * @returns Search results with hits and metadata
+     *
+     * @example
+     * ```ts
+     * // Basic search
+     * const results = await client.search('customer email');
+     * console.log('Found:', results.data.totalHits, 'results');
+     * results.data.hits.forEach(hit => console.log(hit.id, hit.structureSlug));
+     *
+     * // Search with structure filter
+     * const userResults = await client.search('john', { structures: 'users' });
+     *
+     * // Search multiple structures with limit
+     * const results = await client.search('active', {
+     *   structures: ['users', 'orders'],
+     *   limit: 50
+     * });
+     * ```
+     */
+    search(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = getSearchApiPath(this.options.workspaceId);
+            const queryParams = { q: query };
+            if (options === null || options === void 0 ? void 0 : options.structures) {
+                const structures = Array.isArray(options.structures)
+                    ? options.structures.join(',')
+                    : options.structures;
+                queryParams.structures = structures;
+            }
+            if (options === null || options === void 0 ? void 0 : options.limit) {
+                queryParams.limit = String(options.limit);
+            }
+            return this.request('GET', path, null, queryParams);
+        });
+    }
 }
 exports.CentraliSDK = CentraliSDK;
 /**
@@ -690,5 +986,38 @@ exports.CentraliSDK = CentraliSDK;
  * // List all triggers:
  * const triggers = await client.triggers.list();
  * triggers.data.forEach(t => console.log(t.name));
+ *
+ * // ---- Smart Queries ----
+ *
+ * // List all smart queries in the workspace:
+ * const allQueries = await client.smartQueries.listAll();
+ *
+ * // List smart queries for a specific structure:
+ * const employeeQueries = await client.smartQueries.list('employee');
+ * employeeQueries.data.forEach(q => console.log(q.name));
+ *
+ * // Get a smart query by name:
+ * const activeQuery = await client.smartQueries.getByName('employee', 'Active Employees');
+ * console.log('Query ID:', activeQuery.data.id);
+ *
+ * // Execute a smart query:
+ * const results = await client.smartQueries.execute('employee', activeQuery.data.id);
+ * console.log('Found:', results.data.length, 'employees');
+ *
+ * // ---- Search ----
+ *
+ * // Basic full-text search:
+ * const searchResults = await client.search('customer email');
+ * console.log('Found:', searchResults.data.totalHits, 'results');
+ * searchResults.data.hits.forEach(hit => console.log(hit.id, hit.structureSlug));
+ *
+ * // Search with structure filter:
+ * const userResults = await client.search('john', { structures: 'users' });
+ *
+ * // Search multiple structures with limit:
+ * const multiResults = await client.search('active', {
+ *   structures: ['users', 'orders'],
+ *   limit: 50
+ * });
  *```
  */

package/index.ts

@@ -186,14 +186,201 @@ export interface InvokeTriggerOptions {
     payload?: Record<string, any>;
 }
 
+/**
+ * Options for deleting a record.
+ */
+export interface DeleteRecordOptions {
+    /** Perform a hard delete (permanent). Default: false (soft delete) */
+    hard?: boolean;
+}
+
 /**
  * Response from invoking a trigger.
  * Currently the API returns the queued job ID as a string.
  */
 export type TriggerInvokeResponse = string;
 
+// =====================================================
+// Smart Query Types
+// =====================================================
+
+/**
+ * Smart query definition stored in the database.
+ */
+export interface SmartQuery {
+    /** Unique identifier (UUID) */
+    id: string;
+    /** Workspace slug where the query belongs */
+    workspaceSlug: string;
+    /** Structure's record slug (e.g., "employee") */
+    recordSlug: string;
+    /** Human-readable name (unique within workspace) */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Query definition object */
+    queryDefinition: SmartQueryDefinition;
+    /** Status (active, archived) */
+    status: string;
+    /** User ID who created the query */
+    createdBy: string;
+    /** User ID who last updated the query */
+    updatedBy: string;
+    /** ISO timestamp of creation */
+    createdAt: string;
+    /** ISO timestamp of last update */
+    updatedAt: string;
+}
+
+/**
+ * Query definition format for smart queries.
+ * Supports filtering, selection, joins, sorting, and pagination.
+ */
+export interface SmartQueryDefinition {
+    /** Fields to select from the structure */
+    select?: string[];
+    /** Filter conditions */
+    where?: SmartQueryWhereClause;
+    /** Join to another structure */
+    join?: SmartQueryJoin;
+    /** Sorting specification */
+    sort?: SmartQuerySort[];
+    /** Maximum number of results */
+    limit?: number;
+    /** Number of results to skip */
+    skip?: number;
+}
+
+/**
+ * Where clause for smart query filtering.
+ * Supports comparison operators and logical operators.
+ */
+export interface SmartQueryWhereClause {
+    /** Field-level conditions */
+    [field: string]: SmartQueryFieldCondition | SmartQueryWhereClause[] | undefined;
+    /** Logical AND of multiple conditions */
+    $and?: SmartQueryWhereClause[];
+    /** Logical OR of multiple conditions */
+    $or?: SmartQueryWhereClause[];
+}
+
+/**
+ * Field-level condition operators for smart query filtering.
+ */
+export interface SmartQueryFieldCondition {
+    /** Equality */
+    $eq?: any;
+    /** Not equal */
+    $ne?: any;
+    /** Greater than */
+    $gt?: number;
+    /** Greater than or equal */
+    $gte?: number;
+    /** Less than */
+    $lt?: number;
+    /** Less than or equal */
+    $lte?: number;
+    /** String starts with */
+    $startsWith?: string;
+    /** String ends with */
+    $endsWith?: string;
+    /** String contains */
+    $contains?: string;
+    /** Regex pattern match */
+    $regex?: string;
+    /** Value in array */
+    $in?: any[];
+    /** Value not in array */
+    $nin?: any[];
+    /** Field exists check */
+    $exists?: boolean;
+    /** JSONB type check */
+    $type?: string;
+}
+
+/**
+ * Join definition for smart queries.
+ */
+export interface SmartQueryJoin {
+    /** Target structure slug to join */
+    foreignSlug: string;
+    /** Field in the main structure */
+    localField: string;
+    /** Field in the foreign structure */
+    foreignField: string;
+    /** Fields to select from the joined structure */
+    select?: string[];
+}
+
+/**
+ * Sort specification for smart queries.
+ */
+export interface SmartQuerySort {
+    /** Field to sort by */
+    field: string;
+    /** Sort direction */
+    direction: 'asc' | 'desc';
+}
 
 
+/**
+ * Options for listing smart queries.
+ */
+export interface ListSmartQueryOptions {
+    /** Page number (default: 1) */
+    page?: number;
+    /** Results per page (default: 20) */
+    limit?: number;
+    /** Search term */
+    search?: string;
+    /** Sort field */
+    sort?: string;
+    /** Sort direction */
+    sortDirection?: 'asc' | 'desc';
+}
+
+// =====================================================
+// Search Types
+// =====================================================
+
+/**
+ * Options for searching records.
+ */
+export interface SearchOptions {
+    /** Filter by structure slug(s). Can be a single slug or array of slugs */
+    structures?: string | string[];
+    /** Maximum number of results to return (default: 20, max: 100) */
+    limit?: number;
+}
+
+/**
+ * A single search result hit.
+ */
+export interface SearchHit {
+    /** The record ID */
+    id: string;
+    /** The record slug (structure type) */
+    recordSlug: string;
+    /** The structure slug */
+    structureSlug: string;
+    /** The indexed record data */
+    [key: string]: unknown;
+}
+
+/**
+ * Response from a search query.
+ */
+export interface SearchResponse {
+    /** Array of matching records */
+    hits: SearchHit[];
+    /** Estimated total number of matching records */
+    totalHits: number;
+    /** Time taken to process the search in milliseconds */
+    processingTimeMs: number;
+    /** The original search query */
+    query: string;
+}
+
 /**
  * Generate the API URL from the base URL by adding the 'api.' subdomain.
  * E.g., https://centrali.io -> https://api.centrali.io
@@ -532,6 +719,56 @@ export function getFunctionTriggerExecuteApiPath(workspaceId: string, triggerId:
     return `data/workspace/${workspaceId}/api/v1/function-triggers/${triggerId}/execute`;
 }
 
+/**
+ * Generate Function Trigger pause API URL PATH.
+ */
+export function getFunctionTriggerPauseApiPath(workspaceId: string, triggerId: string): string {
+    return `data/workspace/${workspaceId}/api/v1/function-triggers/${triggerId}/pause`;
+}
+
+/**
+ * Generate Function Trigger resume API URL PATH.
+ */
+export function getFunctionTriggerResumeApiPath(workspaceId: string, triggerId: string): string {
+    return `data/workspace/${workspaceId}/api/v1/function-triggers/${triggerId}/resume`;
+}
+
+/**
+ * Generate Smart Queries base API URL PATH for workspace-level operations.
+ */
+export function getSmartQueriesApiPath(workspaceId: string): string {
+    return `data/workspace/${workspaceId}/api/v1/smart-queries`;
+}
+
+/**
+ * Generate Smart Queries API URL PATH for structure-level operations.
+ */
+export function getSmartQueriesStructureApiPath(workspaceId: string, structureSlug: string, queryId?: string): string {
+    const basePath = `data/workspace/${workspaceId}/api/v1/smart-queries/slug/${structureSlug}`;
+    return queryId ? `${basePath}/${queryId}` : basePath;
+}
+
+/**
+ * Generate Smart Query by name API URL PATH.
+ */
+export function getSmartQueryByNameApiPath(workspaceId: string, structureSlug: string, name: string): string {
+    return `data/workspace/${workspaceId}/api/v1/smart-queries/slug/${structureSlug}/name/${encodeURIComponent(name)}`;
+}
+
+/**
+ * Generate Smart Query execute API URL PATH.
+ */
+export function getSmartQueryExecuteApiPath(workspaceId: string, structureSlug: string, queryId: string): string {
+    return `data/workspace/${workspaceId}/api/v1/smart-queries/slug/${structureSlug}/execute/${queryId}`;
+}
+
+/**
+ * Generate Search API URL PATH.
+ */
+export function getSearchApiPath(workspaceId: string): string {
+    return `search/workspace/${workspaceId}/api/v1/records/search`;
+}
+
 // =====================================================
 // Triggers Manager
 // =====================================================
@@ -657,6 +894,192 @@ export class TriggersManager {
         };
         return this.requestFn<FunctionTrigger[]>('GET', path, null, params);
     }
+
+    /**
+     * Pause a function trigger.
+     *
+     * Pauses an event-driven or scheduled trigger to temporarily disable it from firing.
+     * When paused, the trigger will not execute until resumed.
+     *
+     * For scheduled triggers, this also pauses the underlying scheduler job.
+     *
+     * @param triggerId - The ID of the trigger to pause
+     * @returns The updated trigger with enabled = false
+     *
+     * @example
+     * ```ts
+     * // Pause a trigger
+     * const result = await client.triggers.pauseTrigger('trigger-id');
+     * console.log('Trigger paused:', result.data.enabled === false);
+     * ```
+     */
+    public pauseTrigger(triggerId: string): Promise<ApiResponse<FunctionTrigger>> {
+        const path = getFunctionTriggerPauseApiPath(this.workspaceId, triggerId);
+        return this.requestFn<FunctionTrigger>('PATCH', path, {});
+    }
+
+    /**
+     * Resume a paused function trigger.
+     *
+     * Resumes a paused event-driven or scheduled trigger to re-enable it.
+     * Once resumed, the trigger will start firing again on matching events or schedules.
+     *
+     * For scheduled triggers, this also resumes the underlying scheduler job.
+     *
+     * @param triggerId - The ID of the trigger to resume
+     * @returns The updated trigger with enabled = true
+     *
+     * @example
+     * ```ts
+     * // Resume a paused trigger
+     * const result = await client.triggers.resumeTrigger('trigger-id');
+     * console.log('Trigger resumed:', result.data.enabled === true);
+     * ```
+     */
+    public resumeTrigger(triggerId: string): Promise<ApiResponse<FunctionTrigger>> {
+        const path = getFunctionTriggerResumeApiPath(this.workspaceId, triggerId);
+        return this.requestFn<FunctionTrigger>('PATCH', path, {});
+    }
+}
+
+// =====================================================
+// Smart Queries Manager
+// =====================================================
+
+/**
+ * SmartQueriesManager provides methods for listing and executing smart queries.
+ * Smart queries are reusable, parameterized queries defined in the console
+ * that can be executed programmatically via the SDK.
+ * Access via `client.smartQueries`.
+ *
+ * Usage:
+ * ```ts
+ * // List smart queries for a structure
+ * const queries = await client.smartQueries.list('employee');
+ *
+ * // Execute a smart query by ID
+ * const results = await client.smartQueries.execute('employee', 'query-uuid');
+ *
+ * // Get a smart query by name
+ * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+ * ```
+ */
+export class SmartQueriesManager {
+    private requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>;
+    private workspaceId: string;
+
+    constructor(
+        workspaceId: string,
+        requestFn: <T>(method: Method, path: string, data?: any, queryParams?: Record<string, any>) => Promise<ApiResponse<T>>
+    ) {
+        this.workspaceId = workspaceId;
+        this.requestFn = requestFn;
+    }
+
+    /**
+     * List all smart queries in the workspace.
+     *
+     * @param options - Optional list parameters (pagination, search, etc.)
+     * @returns List of smart queries with pagination metadata
+     *
+     * @example
+     * ```ts
+     * // List all smart queries
+     * const queries = await client.smartQueries.listAll();
+     *
+     * // With pagination
+     * const queries = await client.smartQueries.listAll({ page: 1, limit: 20 });
+     * ```
+     */
+    public listAll(options?: ListSmartQueryOptions): Promise<ApiResponse<SmartQuery[]>> {
+        const path = getSmartQueriesApiPath(this.workspaceId);
+        return this.requestFn<SmartQuery[]>('GET', path, null, options);
+    }
+
+    /**
+     * List smart queries for a specific structure.
+     *
+     * @param structureSlug - The structure's record slug (e.g., "employee")
+     * @param options - Optional list parameters (pagination, search, etc.)
+     * @returns List of smart queries for the structure
+     *
+     * @example
+     * ```ts
+     * // List queries for employee structure
+     * const queries = await client.smartQueries.list('employee');
+     *
+     * // With pagination and search
+     * const queries = await client.smartQueries.list('employee', {
+     *   page: 1,
+     *   limit: 10,
+     *   search: 'active'
+     * });
+     * ```
+     */
+    public list(structureSlug: string, options?: ListSmartQueryOptions): Promise<ApiResponse<SmartQuery[]>> {
+        const path = getSmartQueriesStructureApiPath(this.workspaceId, structureSlug);
+        return this.requestFn<SmartQuery[]>('GET', path, null, options);
+    }
+
+    /**
+     * Get a smart query by ID.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @returns The smart query details
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.get('employee', 'query-uuid');
+     * console.log('Query name:', query.data.name);
+     * ```
+     */
+    public get(structureSlug: string, queryId: string): Promise<ApiResponse<SmartQuery>> {
+        const path = getSmartQueriesStructureApiPath(this.workspaceId, structureSlug, queryId);
+        return this.requestFn<SmartQuery>('GET', path);
+    }
+
+    /**
+     * Get a smart query by name.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param name - The smart query name
+     * @returns The smart query details
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+     * console.log('Query ID:', query.data.id);
+     * ```
+     */
+    public getByName(structureSlug: string, name: string): Promise<ApiResponse<SmartQuery>> {
+        const path = getSmartQueryByNameApiPath(this.workspaceId, structureSlug, name);
+        return this.requestFn<SmartQuery>('GET', path);
+    }
+
+    /**
+     * Execute a smart query and return results.
+     *
+     * Note: Pagination (limit/skip) is defined in the query definition itself,
+     * not at execution time.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @returns Query results
+     *
+     * @example
+     * ```ts
+     * const results = await client.smartQueries.execute('employee', 'query-uuid');
+     * console.log('Found:', results.data.length, 'records');
+     * ```
+     */
+    public execute<T = any>(
+        structureSlug: string,
+        queryId: string
+    ): Promise<ApiResponse<T[]>> {
+        const path = getSmartQueryExecuteApiPath(this.workspaceId, structureSlug, queryId);
+        return this.requestFn<T[]>('GET', path);
+    }
 }
 
 /**
@@ -668,6 +1091,7 @@ export class CentraliSDK {
     private options: CentraliSDKOptions;
     private _realtime: RealtimeManager | null = null;
     private _triggers: TriggersManager | null = null;
+    private _smartQueries: SmartQueriesManager | null = null;
 
     constructor(options: CentraliSDKOptions) {
         this.options = options;
@@ -782,6 +1206,35 @@ export class CentraliSDK {
         return this._triggers;
     }
 
+    /**
+     * Smart Queries namespace for listing and executing smart queries.
+     *
+     * Usage:
+     * ```ts
+     * // List all smart queries in workspace
+     * const allQueries = await client.smartQueries.listAll();
+     *
+     * // List smart queries for a structure
+     * const queries = await client.smartQueries.list('employee');
+     *
+     * // Get a smart query by name
+     * const query = await client.smartQueries.getByName('employee', 'Active Employees');
+     *
+     * // Execute a smart query
+     * const results = await client.smartQueries.execute('employee', query.data.id);
+     * console.log('Found:', results.data.length, 'records');
+     * ```
+     */
+    public get smartQueries(): SmartQueriesManager {
+        if (!this._smartQueries) {
+            this._smartQueries = new SmartQueriesManager(
+                this.options.workspaceId,
+                this.request.bind(this)
+            );
+        }
+        return this._smartQueries;
+    }
+
     /**
      * Manually set or update the bearer token for subsequent requests.
      */
@@ -831,6 +1284,10 @@ export class CentraliSDK {
         if (Array.isArray(resp.data)) {
             return { data: resp.data as T };
         }
+        // Handle { result } responses (smart queries and some other endpoints)
+        if ('result' in resp.data && !('data' in resp.data)) {
+            return { data: (resp.data as any).result as T };
+        }
         // Handle objects that don't have a data property (legacy endpoints)
         if (!('data' in resp.data)) {
             return { data: resp.data as T };
@@ -894,13 +1351,24 @@ export class CentraliSDK {
         return this.request('PUT', path, {  ...updates });
     }
 
-    /** Delete a record by ID. */
+    /** Delete a record by ID (soft delete by default, can be restored). */
     public deleteRecord(
         recordSlug: string,
-        id: string
+        id: string,
+        options?: DeleteRecordOptions
     ): Promise<ApiResponse<null>> {
         const path = getRecordApiPath(this.options.workspaceId, recordSlug, id);
-        return this.request('DELETE', path);
+        const queryParams = options?.hard ? { hard: 'true' } : undefined;
+        return this.request('DELETE', path, null, queryParams);
+    }
+
+    /** Restore a soft-deleted record by ID. */
+    public restoreRecord(
+        recordSlug: string,
+        id: string
+    ): Promise<ApiResponse<null>> {
+        const path = getRecordApiPath(this.options.workspaceId, recordSlug, id) + '/restore';
+        return this.request('POST', path);
     }
 
 
@@ -929,6 +1397,54 @@ export class CentraliSDK {
         });
     }
 
+    // ------------------ Search API Methods ------------------
+
+    /**
+     * Search records across the workspace using full-text search.
+     *
+     * @param query - The search query string
+     * @param options - Optional search parameters
+     * @returns Search results with hits and metadata
+     *
+     * @example
+     * ```ts
+     * // Basic search
+     * const results = await client.search('customer email');
+     * console.log('Found:', results.data.totalHits, 'results');
+     * results.data.hits.forEach(hit => console.log(hit.id, hit.structureSlug));
+     *
+     * // Search with structure filter
+     * const userResults = await client.search('john', { structures: 'users' });
+     *
+     * // Search multiple structures with limit
+     * const results = await client.search('active', {
+     *   structures: ['users', 'orders'],
+     *   limit: 50
+     * });
+     * ```
+     */
+    public async search(
+        query: string,
+        options?: SearchOptions
+    ): Promise<ApiResponse<SearchResponse>> {
+        const path = getSearchApiPath(this.options.workspaceId);
+
+        const queryParams: Record<string, string> = { q: query };
+
+        if (options?.structures) {
+            const structures = Array.isArray(options.structures)
+                ? options.structures.join(',')
+                : options.structures;
+            queryParams.structures = structures;
+        }
+
+        if (options?.limit) {
+            queryParams.limit = String(options.limit);
+        }
+
+        return this.request<SearchResponse>('GET', path, null, queryParams);
+    }
+
 }
 
 /**
@@ -989,5 +1505,38 @@ export class CentraliSDK {
  * // List all triggers:
  * const triggers = await client.triggers.list();
  * triggers.data.forEach(t => console.log(t.name));
+ *
+ * // ---- Smart Queries ----
+ *
+ * // List all smart queries in the workspace:
+ * const allQueries = await client.smartQueries.listAll();
+ *
+ * // List smart queries for a specific structure:
+ * const employeeQueries = await client.smartQueries.list('employee');
+ * employeeQueries.data.forEach(q => console.log(q.name));
+ *
+ * // Get a smart query by name:
+ * const activeQuery = await client.smartQueries.getByName('employee', 'Active Employees');
+ * console.log('Query ID:', activeQuery.data.id);
+ *
+ * // Execute a smart query:
+ * const results = await client.smartQueries.execute('employee', activeQuery.data.id);
+ * console.log('Found:', results.data.length, 'employees');
+ *
+ * // ---- Search ----
+ *
+ * // Basic full-text search:
+ * const searchResults = await client.search('customer email');
+ * console.log('Found:', searchResults.data.totalHits, 'results');
+ * searchResults.data.hits.forEach(hit => console.log(hit.id, hit.structureSlug));
+ *
+ * // Search with structure filter:
+ * const userResults = await client.search('john', { structures: 'users' });
+ *
+ * // Search multiple structures with limit:
+ * const multiResults = await client.search('active', {
+ *   structures: ['users', 'orders'],
+ *   limit: 50
+ * });
  *```
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@centrali-io/centrali-sdk",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "Centrali Node SDK",
   "main": "dist/index.js",
   "type": "commonjs",