@centrali-io/centrali-sdk 3.0.8 → 3.1.0

package/index.ts

@@ -517,6 +517,7 @@ export interface FunctionTrigger {
     executionType: TriggerExecutionType;
     triggerMetadata: Record<string, any>;
     schedulerJobId?: string;
+    enabled: boolean;
     createdBy: string;
     updatedBy: string;
     createdAt?: string;
@@ -1314,6 +1315,364 @@ export interface SmartQueryExecuteResult<T = any> {
     };
 }
 
+// =====================================================
+// Structure Types (Configuration-as-Code)
+// =====================================================
+
+/**
+ * Property type identifiers for structure properties.
+ */
+export type PropertyType = 'string' | 'number' | 'boolean' | 'datetime' | 'array' | 'object' | 'reference';
+
+/**
+ * Schema discovery mode for a structure.
+ */
+export type SchemaDiscoveryMode = 'strict' | 'schemaless' | 'auto-evolving';
+
+/**
+ * Base property definition shared by all property types.
+ */
+export interface BasePropertyDefinition {
+    id?: string;
+    name: string;
+    type: PropertyType;
+    description?: string;
+    required?: boolean;
+    nullable?: boolean;
+    default?: any;
+    enum?: any[];
+    isUnique?: boolean;
+    immutable?: boolean;
+}
+
+/**
+ * String property definition.
+ */
+export interface StringPropertyDefinition extends BasePropertyDefinition {
+    type: 'string';
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    renderAs?: 'textarea' | 'secret' | 'color' | 'code' | 'html' | 'markdown';
+    not?: any[];
+    isSecret?: boolean;
+}
+
+/**
+ * Number property definition.
+ */
+export interface NumberPropertyDefinition extends BasePropertyDefinition {
+    type: 'number';
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    multipleOf?: number;
+    expression?: string;
+    computedMode?: 'persisted' | 'virtual';
+    autoIncrement?: { startAt: number; incrementBy?: number };
+}
+
+/**
+ * Boolean property definition.
+ */
+export interface BooleanPropertyDefinition extends BasePropertyDefinition {
+    type: 'boolean';
+}
+
+/**
+ * DateTime property definition.
+ */
+export interface DateTimePropertyDefinition extends BasePropertyDefinition {
+    type: 'datetime';
+    earliestDate?: string;
+    latestDate?: string;
+    exclusiveEarliest?: boolean;
+    exclusiveLatest?: boolean;
+    expression?: string;
+    computedMode?: 'persisted' | 'virtual';
+}
+
+/**
+ * Array property definition.
+ */
+export interface ArrayPropertyDefinition extends BasePropertyDefinition {
+    type: 'array';
+    items: { type: string };
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    itemSchema?: PropertyDefinition[];
+    strictProperties?: boolean;
+}
+
+/**
+ * Object property definition.
+ */
+export interface ObjectPropertyDefinition extends BasePropertyDefinition {
+    type: 'object';
+    properties?: PropertyDefinition[];
+    requiredProperties?: string[];
+    strictProperties?: boolean;
+}
+
+/**
+ * Reference property definition for foreign key-like relationships.
+ */
+export interface ReferencePropertyDefinition extends BasePropertyDefinition {
+    type: 'reference';
+    target: string;
+    targetField?: string;
+    displayField?: string;
+    relationship: 'many-to-one' | 'one-to-one' | 'many-to-many';
+    onDelete: 'restrict' | 'cascade' | 'set_null';
+}
+
+/**
+ * Union of all property definition types.
+ */
+export type PropertyDefinition =
+    | StringPropertyDefinition
+    | NumberPropertyDefinition
+    | BooleanPropertyDefinition
+    | DateTimePropertyDefinition
+    | ArrayPropertyDefinition
+    | ObjectPropertyDefinition
+    | ReferencePropertyDefinition;
+
+/**
+ * Full structure definition.
+ */
+export interface Structure {
+    id: string;
+    name: string;
+    workspaceSlug: string;
+    recordSlug: string;
+    description?: string;
+    properties: PropertyDefinition[];
+    defaultSearchField?: string;
+    metadata?: {
+        recordWritesLocked?: boolean;
+        structureWritesLocked?: boolean;
+        lastMigrationId?: string;
+        migrationInProgress?: boolean;
+        migrationJobId?: string;
+        migrationStartedAt?: string;
+        migrationStartedBy?: string;
+    };
+    status: 'active' | 'inactive';
+    schemaDiscoveryMode: SchemaDiscoveryMode;
+    enableVersioning: boolean;
+    isDeleted: boolean;
+    createdBy: string;
+    lastUpdatedBy: string;
+    createdAt: string;
+    updatedAt: string;
+    tags?: string[];
+}
+
+/**
+ * Input for creating a new structure.
+ */
+export interface CreateStructureInput {
+    name: string;
+    slug: string;
+    description?: string;
+    properties?: PropertyDefinition[];
+    enableVersioning?: boolean;
+    schemaDiscoveryMode?: SchemaDiscoveryMode;
+    tags?: string[];
+}
+
+/**
+ * Input for updating an existing structure.
+ */
+export interface UpdateStructureInput {
+    name?: string;
+    description?: string;
+    properties?: PropertyDefinition[];
+    enableVersioning?: boolean;
+    tags?: string[];
+}
+
+/**
+ * Options for listing structures.
+ */
+export interface ListStructuresOptions {
+    page?: number;
+    limit?: number;
+}
+
+/**
+ * Input for validating a structure definition.
+ */
+export interface ValidateStructureInput {
+    name?: string;
+    slug?: string;
+    properties?: PropertyDefinition[];
+}
+
+// =====================================================
+// Compute Function Types (Configuration-as-Code)
+// =====================================================
+
+/**
+ * Compute function definition.
+ */
+export interface ComputeFunction {
+    id: string;
+    name: string;
+    code: string;
+    description?: string;
+    workspaceSlug: string;
+    createdBy: string;
+    updatedBy?: string;
+    timeoutMs?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+/**
+ * Input for creating a new compute function.
+ */
+export interface CreateComputeFunctionInput {
+    name: string;
+    slug: string;
+    code: string;
+    description?: string;
+    timeout?: number;
+}
+
+/**
+ * Input for updating an existing compute function.
+ */
+export interface UpdateComputeFunctionInput {
+    name?: string;
+    description?: string;
+    code?: string;
+    timeout?: number;
+}
+
+/**
+ * Options for listing compute functions.
+ */
+export interface ListComputeFunctionsOptions {
+    page?: number;
+    limit?: number;
+    search?: string;
+    searchField?: string;
+}
+
+/**
+ * Input for test-executing a compute function without saving.
+ */
+export interface TestComputeFunctionInput {
+    code: string;
+    input?: Record<string, any>;
+}
+
+/**
+ * Result from test-executing a compute function.
+ */
+export interface TestComputeFunctionResult {
+    success: boolean;
+    output?: any;
+    duration_ms?: number;
+    logs?: string[];
+    error?: string;
+}
+
+// =====================================================
+// Trigger CRUD Types (Configuration-as-Code)
+// =====================================================
+
+/**
+ * Input for creating a new function trigger.
+ */
+export interface CreateTriggerInput {
+    name: string;
+    functionId: string;
+    executionType: TriggerExecutionType;
+    description?: string;
+    triggerMetadata?: Record<string, any>;
+    enabled?: boolean;
+}
+
+/**
+ * Input for updating an existing function trigger.
+ */
+export interface UpdateTriggerInput {
+    name?: string;
+    description?: string;
+    enabled?: boolean;
+    triggerMetadata?: Record<string, any>;
+}
+
+/**
+ * Options for listing all triggers (not filtered by type).
+ */
+export interface ListAllTriggersOptions {
+    page?: number;
+    limit?: number;
+    functionId?: string;
+    executionType?: TriggerExecutionType;
+    includeHealth?: boolean;
+}
+
+/**
+ * Health status of a trigger.
+ */
+export type TriggerHealthStatus = 'healthy' | 'warning' | 'error' | 'dead' | 'never_run' | 'paused';
+
+/**
+ * Health metrics for a trigger.
+ */
+export interface TriggerHealthMetrics {
+    lastRunAt: string | null;
+    successCount: number;
+    failureCount: number;
+    avgExecutionTimeMs: number;
+    totalRuns: number;
+}
+
+/**
+ * Trigger with health metrics included.
+ */
+export interface TriggerWithHealth extends FunctionTrigger {
+    health: TriggerHealthMetrics;
+    healthStatus: TriggerHealthStatus;
+}
+
+// =====================================================
+// Smart Query CRUD Types (Configuration-as-Code)
+// =====================================================
+
+/**
+ * Input for creating a new smart query.
+ */
+export interface CreateSmartQueryInput {
+    name: string;
+    description?: string;
+    queryDefinition: SmartQueryDefinition;
+}
+
+/**
+ * Input for updating an existing smart query.
+ */
+export interface UpdateSmartQueryInput {
+    name?: string;
+    description?: string;
+    queryDefinition?: SmartQueryDefinition;
+}
+
+/**
+ * Input for test-executing a smart query definition without saving.
+ */
+export interface TestSmartQueryInput {
+    queryDefinition: SmartQueryDefinition;
+    variables?: Record<string, string>;
+}
+
 // =====================================================
 // Search Types
 // =====================================================
@@ -2086,6 +2445,62 @@ export function getStructureInsightsApiPath(workspaceId: string, structureSlug:
     return `data/workspace/${workspaceId}/api/v1/structures/${structureSlug}/insights`;
 }
 
+// =====================================================
+// Structure API Path Helpers (Configuration-as-Code)
+// =====================================================
+
+/**
+ * Generate Structures base API URL PATH.
+ */
+export function getStructuresApiPath(workspaceId: string, structureId?: string): string {
+    const basePath = `data/workspace/${workspaceId}/api/v1/structures`;
+    return structureId ? `${basePath}/${structureId}` : basePath;
+}
+
+/**
+ * Generate Structure by slug API URL PATH.
+ */
+export function getStructureBySlugApiPath(workspaceId: string, recordSlug: string): string {
+    return `data/workspace/${workspaceId}/api/v1/structures/slug/${recordSlug}`;
+}
+
+/**
+ * Generate Structure validate API URL PATH.
+ */
+export function getStructureValidateApiPath(workspaceId: string): string {
+    return `data/workspace/${workspaceId}/api/v1/structures/validate`;
+}
+
+// =====================================================
+// Compute Function API Path Helpers (Configuration-as-Code)
+// =====================================================
+
+/**
+ * Generate Compute Functions base API URL PATH.
+ */
+export function getComputeFunctionsApiPath(workspaceId: string, functionId?: string): string {
+    const basePath = `data/workspace/${workspaceId}/api/v1/compute-functions`;
+    return functionId ? `${basePath}/${functionId}` : basePath;
+}
+
+/**
+ * Generate Compute Function test execution API URL PATH.
+ */
+export function getComputeFunctionTestApiPath(workspaceId: string): string {
+    return `data/workspace/${workspaceId}/api/v1/compute-functions/test`;
+}
+
+// =====================================================
+// Smart Query Test API Path Helper (Configuration-as-Code)
+// =====================================================
+
+/**
+ * Generate Smart Query test execution API URL PATH.
+ */
+export function getSmartQueryTestApiPath(workspaceId: string, structureSlug: string): string {
+    return `data/workspace/${workspaceId}/api/v1/smart-queries/slug/${structureSlug}/test`;
+}
+
 // =====================================================
 // Validation API Path Helpers
 // =====================================================
@@ -2670,28 +3085,140 @@ export class TriggersManager {
         const path = getFunctionTriggerResumeApiPath(this.workspaceId, triggerId);
         return this.requestFn<FunctionTrigger>('PATCH', path, {});
     }
-}
 
-// =====================================================
-// Smart Queries Manager
-// =====================================================
+    /**
+     * Create a new function trigger.
+     *
+     * @param input - The trigger definition
+     * @returns The created trigger
+     *
+     * @example
+     * ```ts
+     * // Create an event-driven trigger
+     * const trigger = await client.triggers.create({
+     *   name: 'On Order Created',
+     *   functionId: 'function-uuid',
+     *   executionType: 'event-driven',
+     *   triggerMetadata: { event: 'record.created', recordSlug: 'orders' }
+     * });
+     *
+     * // Create a scheduled trigger
+     * const scheduled = await client.triggers.create({
+     *   name: 'Daily Report',
+     *   functionId: 'function-uuid',
+     *   executionType: 'scheduled',
+     *   triggerMetadata: { scheduleType: 'cron', cronExpression: '0 9 * * *', timezone: 'America/New_York' }
+     * });
+     * ```
+     */
+    public create(input: CreateTriggerInput): Promise<ApiResponse<FunctionTrigger>> {
+        const path = getFunctionTriggersApiPath(this.workspaceId);
+        return this.requestFn<FunctionTrigger>('POST', path, input);
+    }
 
-/**
- * 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');
+    /**
+     * Update an existing function trigger.
+     *
+     * @param triggerId - The trigger UUID
+     * @param input - The fields to update
+     * @returns The updated trigger
+     *
+     * @example
+     * ```ts
+     * const updated = await client.triggers.update('trigger-uuid', {
+     *   name: 'Updated Trigger Name',
+     *   enabled: false
+     * });
+     * ```
+     */
+    public update(triggerId: string, input: UpdateTriggerInput): Promise<ApiResponse<FunctionTrigger>> {
+        const path = getFunctionTriggersApiPath(this.workspaceId, triggerId);
+        return this.requestFn<FunctionTrigger>('PUT', path, input);
+    }
+
+    /**
+     * Delete a function trigger.
+     *
+     * @param triggerId - The trigger UUID
+     *
+     * @example
+     * ```ts
+     * await client.triggers.delete('trigger-uuid');
+     * ```
+     */
+    public delete(triggerId: string): Promise<ApiResponse<void>> {
+        const path = getFunctionTriggersApiPath(this.workspaceId, triggerId);
+        return this.requestFn<void>('DELETE', path);
+    }
+
+    /**
+     * List all triggers in the workspace (not filtered by execution type).
+     * Unlike `list()` which only returns on-demand triggers, `listAll()` returns
+     * triggers of all types with optional filtering.
+     *
+     * @param options - Optional list parameters (pagination, filtering, health)
+     * @returns List of triggers
+     *
+     * @example
+     * ```ts
+     * // List all triggers
+     * const all = await client.triggers.listAll();
+     *
+     * // Filter by execution type
+     * const scheduled = await client.triggers.listAll({ executionType: 'scheduled' });
+     *
+     * // Include health metrics
+     * const withHealth = await client.triggers.listAll({ includeHealth: true });
+     * ```
+     */
+    public listAll(options?: ListAllTriggersOptions): Promise<ApiResponse<(FunctionTrigger | TriggerWithHealth)[]>> {
+        const path = getFunctionTriggersApiPath(this.workspaceId);
+        return this.requestFn<(FunctionTrigger | TriggerWithHealth)[]>('GET', path, null, options);
+    }
+
+    /**
+     * Get a trigger by ID with full details (no on-demand type restriction).
+     * Unlike `get()` which validates on-demand type, `getDetails()` returns
+     * any trigger type.
+     *
+     * @param triggerId - The trigger UUID
+     * @param options - Optional parameters (includeHealth)
+     * @returns The trigger details
+     *
+     * @example
+     * ```ts
+     * const trigger = await client.triggers.getDetails('trigger-uuid');
+     *
+     * // With health metrics
+     * const withHealth = await client.triggers.getDetails('trigger-uuid', { includeHealth: true });
+     * ```
+     */
+    public getDetails(triggerId: string, options?: { includeHealth?: boolean }): Promise<ApiResponse<FunctionTrigger | TriggerWithHealth>> {
+        const path = getFunctionTriggersApiPath(this.workspaceId, triggerId);
+        return this.requestFn<FunctionTrigger | TriggerWithHealth>('GET', path, null, options);
+    }
+}
+
+// =====================================================
+// 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 {
@@ -2829,6 +3356,96 @@ export class SmartQueriesManager {
         const body = options?.variables ? { variables: options.variables } : undefined;
         return this.requestFn<T[]>('POST', path, body);
     }
+
+    /**
+     * Create a new smart query for a structure.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param input - The smart query definition
+     * @returns The created smart query
+     *
+     * @example
+     * ```ts
+     * const query = await client.smartQueries.create('orders', {
+     *   name: 'Active Orders',
+     *   description: 'All orders with active status',
+     *   queryDefinition: {
+     *     where: { status: { $eq: 'active' } },
+     *     sort: [{ field: 'createdAt', direction: 'desc' }],
+     *     limit: 100
+     *   }
+     * });
+     * ```
+     */
+    public create(structureSlug: string, input: CreateSmartQueryInput): Promise<ApiResponse<SmartQuery>> {
+        const path = getSmartQueriesStructureApiPath(this.workspaceId, structureSlug);
+        return this.requestFn<SmartQuery>('POST', path, input);
+    }
+
+    /**
+     * Update an existing smart query.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     * @param input - The fields to update
+     * @returns The updated smart query
+     *
+     * @example
+     * ```ts
+     * const updated = await client.smartQueries.update('orders', 'query-uuid', {
+     *   name: 'Active Orders v2',
+     *   queryDefinition: {
+     *     where: { status: { $in: ['active', 'processing'] } },
+     *     limit: 200
+     *   }
+     * });
+     * ```
+     */
+    public update(structureSlug: string, queryId: string, input: UpdateSmartQueryInput): Promise<ApiResponse<SmartQuery>> {
+        const path = getSmartQueriesStructureApiPath(this.workspaceId, structureSlug, queryId);
+        return this.requestFn<SmartQuery>('PUT', path, input);
+    }
+
+    /**
+     * Delete a smart query.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param queryId - The smart query UUID
+     *
+     * @example
+     * ```ts
+     * await client.smartQueries.delete('orders', 'query-uuid');
+     * ```
+     */
+    public delete(structureSlug: string, queryId: string): Promise<ApiResponse<void>> {
+        const path = getSmartQueriesStructureApiPath(this.workspaceId, structureSlug, queryId);
+        return this.requestFn<void>('DELETE', path);
+    }
+
+    /**
+     * Test execute a query definition without saving it.
+     * Useful for validating query syntax and previewing results before creating.
+     *
+     * @param structureSlug - The structure's record slug
+     * @param input - The query definition to test and optional variables
+     * @returns Test execution results
+     *
+     * @example
+     * ```ts
+     * const result = await client.smartQueries.test('orders', {
+     *   queryDefinition: {
+     *     where: { amount: { $gte: 100 } },
+     *     select: ['id', 'amount', 'status'],
+     *     limit: 5
+     *   }
+     * });
+     * console.log('Preview results:', result.data);
+     * ```
+     */
+    public test<T = any>(structureSlug: string, input: TestSmartQueryInput): Promise<ApiResponse<T[]>> {
+        const path = getSmartQueryTestApiPath(this.workspaceId, structureSlug);
+        return this.requestFn<T[]>('POST', path, input);
+    }
 }
 
 // =====================================================
@@ -3382,6 +3999,340 @@ export class AllowedDomainsManager {
     }
 }
 
+// =====================================================
+// Structures Manager (Configuration-as-Code)
+// =====================================================
+
+/**
+ * StructuresManager provides methods for managing data structures (schemas).
+ * Structures define the shape of records including properties, validation rules,
+ * and schema discovery modes.
+ * Access via `client.structures`.
+ *
+ * Usage:
+ * ```ts
+ * // List all structures
+ * const structures = await client.structures.list();
+ *
+ * // Create a new structure
+ * const structure = await client.structures.create({
+ *   name: 'Orders',
+ *   slug: 'orders',
+ *   properties: [
+ *     { name: 'title', type: 'string', required: true },
+ *     { name: 'amount', type: 'number', minimum: 0 }
+ *   ]
+ * });
+ *
+ * // Validate before creating
+ * const validation = await client.structures.validate({ slug: 'orders' });
+ * ```
+ */
+export class StructuresManager {
+    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 structures in the workspace.
+     *
+     * @param options - Optional list parameters (pagination)
+     * @returns List of structures
+     *
+     * @example
+     * ```ts
+     * const structures = await client.structures.list();
+     * const page2 = await client.structures.list({ page: 2, limit: 10 });
+     * ```
+     */
+    public list(options?: ListStructuresOptions): Promise<ApiResponse<Structure[]>> {
+        const path = getStructuresApiPath(this.workspaceId);
+        return this.requestFn<Structure[]>('GET', path, null, options);
+    }
+
+    /**
+     * Get a structure by ID.
+     *
+     * @param structureId - The structure UUID
+     * @returns The structure details
+     *
+     * @example
+     * ```ts
+     * const structure = await client.structures.get('structure-uuid');
+     * console.log('Properties:', structure.data.properties.length);
+     * ```
+     */
+    public get(structureId: string): Promise<ApiResponse<Structure>> {
+        const path = getStructuresApiPath(this.workspaceId, structureId);
+        return this.requestFn<Structure>('GET', path);
+    }
+
+    /**
+     * Get a structure by its record slug.
+     *
+     * @param recordSlug - The structure's record slug (e.g., "orders")
+     * @returns The structure details
+     *
+     * @example
+     * ```ts
+     * const structure = await client.structures.getBySlug('orders');
+     * console.log('Structure name:', structure.data.name);
+     * ```
+     */
+    public getBySlug(recordSlug: string): Promise<ApiResponse<Structure>> {
+        const path = getStructureBySlugApiPath(this.workspaceId, recordSlug);
+        return this.requestFn<Structure>('GET', path);
+    }
+
+    /**
+     * Create a new structure.
+     *
+     * @param input - The structure definition
+     * @returns The created structure
+     *
+     * @example
+     * ```ts
+     * const structure = await client.structures.create({
+     *   name: 'Orders',
+     *   slug: 'orders',
+     *   description: 'Customer orders',
+     *   properties: [
+     *     { name: 'title', type: 'string', required: true },
+     *     { name: 'amount', type: 'number', minimum: 0 },
+     *     { name: 'status', type: 'string', enum: ['pending', 'completed'] }
+     *   ],
+     *   enableVersioning: true,
+     *   schemaDiscoveryMode: 'strict'
+     * });
+     * ```
+     */
+    public create(input: CreateStructureInput): Promise<ApiResponse<Structure>> {
+        const path = getStructuresApiPath(this.workspaceId);
+        return this.requestFn<Structure>('POST', path, input);
+    }
+
+    /**
+     * Update an existing structure.
+     *
+     * @param structureId - The structure UUID
+     * @param input - The fields to update
+     * @returns The updated structure
+     *
+     * @example
+     * ```ts
+     * const updated = await client.structures.update('structure-uuid', {
+     *   name: 'Updated Orders',
+     *   properties: [
+     *     { name: 'title', type: 'string', required: true },
+     *     { name: 'amount', type: 'number', minimum: 0 },
+     *     { name: 'priority', type: 'number' }
+     *   ]
+     * });
+     * ```
+     */
+    public update(structureId: string, input: UpdateStructureInput): Promise<ApiResponse<Structure>> {
+        const path = getStructuresApiPath(this.workspaceId, structureId);
+        return this.requestFn<Structure>('PUT', path, input);
+    }
+
+    /**
+     * Delete a structure.
+     *
+     * @param structureId - The structure UUID
+     *
+     * @example
+     * ```ts
+     * await client.structures.delete('structure-uuid');
+     * ```
+     */
+    public delete(structureId: string): Promise<ApiResponse<void>> {
+        const path = getStructuresApiPath(this.workspaceId, structureId);
+        return this.requestFn<void>('DELETE', path);
+    }
+
+    /**
+     * Validate a structure definition without creating it.
+     * Useful for checking slug uniqueness and property validity before creation.
+     *
+     * @param input - The structure definition to validate
+     * @returns Validation result
+     *
+     * @example
+     * ```ts
+     * const result = await client.structures.validate({
+     *   slug: 'orders',
+     *   properties: [{ name: 'title', type: 'string' }]
+     * });
+     * ```
+     */
+    public validate(input: ValidateStructureInput): Promise<ApiResponse<any>> {
+        const path = getStructureValidateApiPath(this.workspaceId);
+        return this.requestFn<any>('POST', path, input);
+    }
+}
+
+// =====================================================
+// Compute Functions Manager (Configuration-as-Code)
+// =====================================================
+
+/**
+ * ComputeFunctionsManager provides methods for managing compute functions.
+ * Compute functions are JavaScript code blocks that can be executed on triggers,
+ * schedules, or on-demand.
+ * Access via `client.functions`.
+ *
+ * Usage:
+ * ```ts
+ * // List all compute functions
+ * const fns = await client.functions.list();
+ *
+ * // Create a new function
+ * const fn = await client.functions.create({
+ *   name: 'Process Order',
+ *   slug: 'process-order',
+ *   code: 'module.exports = async (ctx) => { return { processed: true }; }'
+ * });
+ *
+ * // Test execute code without saving
+ * const result = await client.functions.testExecute({
+ *   code: 'module.exports = async (ctx) => { return ctx.input; }',
+ *   input: { orderId: '123' }
+ * });
+ * ```
+ */
+export class ComputeFunctionsManager {
+    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 compute functions in the workspace.
+     *
+     * @param options - Optional list parameters (pagination, search)
+     * @returns List of compute functions
+     *
+     * @example
+     * ```ts
+     * const fns = await client.functions.list();
+     * const searched = await client.functions.list({ search: 'order', limit: 10 });
+     * ```
+     */
+    public list(options?: ListComputeFunctionsOptions): Promise<ApiResponse<ComputeFunction[]>> {
+        const path = getComputeFunctionsApiPath(this.workspaceId);
+        return this.requestFn<ComputeFunction[]>('GET', path, null, options);
+    }
+
+    /**
+     * Get a compute function by ID.
+     *
+     * @param functionId - The compute function UUID
+     * @returns The compute function details
+     *
+     * @example
+     * ```ts
+     * const fn = await client.functions.get('function-uuid');
+     * console.log('Function name:', fn.data.name);
+     * ```
+     */
+    public get(functionId: string): Promise<ApiResponse<ComputeFunction>> {
+        const path = getComputeFunctionsApiPath(this.workspaceId, functionId);
+        return this.requestFn<ComputeFunction>('GET', path);
+    }
+
+    /**
+     * Create a new compute function.
+     *
+     * @param input - The function definition
+     * @returns The created compute function
+     *
+     * @example
+     * ```ts
+     * const fn = await client.functions.create({
+     *   name: 'Process Order',
+     *   slug: 'process-order',
+     *   code: 'module.exports = async (ctx) => { return { processed: true }; }',
+     *   description: 'Processes incoming orders',
+     *   timeout: 60000
+     * });
+     * ```
+     */
+    public create(input: CreateComputeFunctionInput): Promise<ApiResponse<ComputeFunction>> {
+        const path = getComputeFunctionsApiPath(this.workspaceId);
+        return this.requestFn<ComputeFunction>('POST', path, input);
+    }
+
+    /**
+     * Update an existing compute function.
+     *
+     * @param functionId - The compute function UUID
+     * @param input - The fields to update
+     * @returns The updated compute function
+     *
+     * @example
+     * ```ts
+     * const updated = await client.functions.update('function-uuid', {
+     *   code: 'module.exports = async (ctx) => { return { v2: true }; }',
+     *   timeout: 120000
+     * });
+     * ```
+     */
+    public update(functionId: string, input: UpdateComputeFunctionInput): Promise<ApiResponse<ComputeFunction>> {
+        const path = getComputeFunctionsApiPath(this.workspaceId, functionId);
+        return this.requestFn<ComputeFunction>('PUT', path, input);
+    }
+
+    /**
+     * Delete a compute function.
+     *
+     * @param functionId - The compute function UUID
+     *
+     * @example
+     * ```ts
+     * await client.functions.delete('function-uuid');
+     * ```
+     */
+    public delete(functionId: string): Promise<ApiResponse<void>> {
+        const path = getComputeFunctionsApiPath(this.workspaceId, functionId);
+        return this.requestFn<void>('DELETE', path);
+    }
+
+    /**
+     * Test execute code without saving it as a function.
+     * Useful for validating function code before creating/updating.
+     *
+     * @param input - The code to test and optional input data
+     * @returns Test execution result including output, duration, and logs
+     *
+     * @example
+     * ```ts
+     * const result = await client.functions.testExecute({
+     *   code: 'module.exports = async (ctx) => { return { sum: ctx.input.a + ctx.input.b }; }',
+     *   input: { a: 1, b: 2 }
+     * });
+     * console.log('Output:', result.data.output); // { sum: 3 }
+     * console.log('Duration:', result.data.duration_ms, 'ms');
+     * ```
+     */
+    public testExecute(input: TestComputeFunctionInput): Promise<ApiResponse<TestComputeFunctionResult>> {
+        const path = getComputeFunctionTestApiPath(this.workspaceId);
+        return this.requestFn<TestComputeFunctionResult>('POST', path, input);
+    }
+}
+
 /**
  * Main Centrali SDK client.
  */
@@ -3396,6 +4347,8 @@ export class CentraliSDK {
     private _validation: ValidationManager | null = null;
     private _orchestrations: OrchestrationsManager | null = null;
     private _allowedDomains: AllowedDomainsManager | null = null;
+    private _structures: StructuresManager | null = null;
+    private _functions: ComputeFunctionsManager | null = null;
     private isRefreshingToken: boolean = false;
     private tokenRefreshPromise: Promise<string> | null = null;
 
@@ -3723,6 +4676,69 @@ export class CentraliSDK {
         return this._allowedDomains;
     }
 
+    /**
+     * Structures namespace for managing data structures (schemas).
+     * Provides CRUD operations and validation for structure definitions.
+     *
+     * Usage:
+     * ```ts
+     * // List all structures
+     * const structures = await client.structures.list();
+     *
+     * // Create a structure
+     * const structure = await client.structures.create({
+     *   name: 'Orders',
+     *   slug: 'orders',
+     *   properties: [{ name: 'title', type: 'string', required: true }]
+     * });
+     *
+     * // Validate before creating
+     * const result = await client.structures.validate({ slug: 'orders' });
+     * ```
+     */
+    public get structures(): StructuresManager {
+        if (!this._structures) {
+            this._structures = new StructuresManager(
+                this.options.workspaceId,
+                this.request.bind(this)
+            );
+        }
+        return this._structures;
+    }
+
+    /**
+     * Functions namespace for managing compute functions.
+     * Provides CRUD operations and test execution for compute function code.
+     *
+     * Usage:
+     * ```ts
+     * // List all functions
+     * const fns = await client.functions.list();
+     *
+     * // Create a function
+     * const fn = await client.functions.create({
+     *   name: 'Process Order',
+     *   slug: 'process-order',
+     *   code: 'module.exports = async (ctx) => { return { ok: true }; }'
+     * });
+     *
+     * // Test execute without saving
+     * const result = await client.functions.testExecute({
+     *   code: 'module.exports = async (ctx) => { return ctx.input; }',
+     *   input: { test: true }
+     * });
+     * ```
+     */
+    public get functions(): ComputeFunctionsManager {
+        if (!this._functions) {
+            this._functions = new ComputeFunctionsManager(
+                this.options.workspaceId,
+                this.request.bind(this)
+            );
+        }
+        return this._functions;
+    }
+
     /**
      * Manually set or update the bearer token for subsequent requests.
      */