@rulebricks/sdk 2.0.0 → 2.5.1

package/dist/api/types/DecisionLog.d.ts

@@ -1,3 +1,4 @@
+import type * as Rulebricks from "../index.js";
 /**
  * Rule/flow execution log entry with request, response, and decision details.
  */
@@ -10,14 +11,22 @@ export interface DecisionLog {
     endpoint?: string | null;
     /** HTTP status code of the response. */
     status?: number | null;
-    /** The request payload sent to the rule/flow. */
-    request?: Record<string, unknown> | null;
-    /** The response payload returned by the rule/flow. */
-    response?: Record<string, unknown> | null;
+    /** The request payload sent to the rule/flow. Can be an object for single requests or an array for bulk operations. */
+    request?: DecisionLog.Request | null;
+    /** The response payload returned by the rule/flow. Can be an object for single responses or an array for bulk operations. */
+    response?: Rulebricks.DecisionLogResponse | null;
     /** Decision details including matched conditions, rows, and evaluation metadata. */
     decision?: Record<string, unknown> | null;
     /** Error message if the execution failed. */
     error?: string | null;
     /** Whether the request/response data was truncated due to size limits. */
     abbreviated?: boolean;
+    /** Accepts any additional properties */
+    [key: string]: any;
+}
+export declare namespace DecisionLog {
+    /**
+     * The request payload sent to the rule/flow. Can be an object for single requests or an array for bulk operations.
+     */
+    type Request = Record<string, unknown> | Record<string, unknown>[];
 }

package/dist/api/types/DecisionLogResponse.d.ts

@@ -1,12 +1,12 @@
 import type * as Rulebricks from "../index.js";
 /**
- * Response containing decision logs or a count.
+ * Response containing decision logs or a count. Returns either {data, cursor} for log queries OR {count} for count queries - these are mutually exclusive based on the count parameter.
  */
 export interface DecisionLogResponse {
-    /** Array of decision log entries (omitted when count=true). */
+    /** Array of decision log entries. Only present when count parameter is not 'true'. */
     data?: Rulebricks.DecisionLog[];
-    /** Pagination cursor for fetching the next page. Null if no more results. */
+    /** Pagination cursor for fetching the next page. Null if no more results. Only present when count parameter is not 'true'. */
     cursor?: string | null;
-    /** Total count of matching logs (only present when count=true parameter is used). */
+    /** Total count of matching logs. Only present when count parameter is 'true'. When this is returned, data and cursor are not included. */
     count?: number;
 }

package/dist/api/types/DeleteRelationshipResponse.d.ts

@@ -1,4 +1,6 @@
 export interface DeleteRelationshipResponse {
     /** Success message. */
     message?: string;
+    /** The ID of the deleted relationship. */
+    id?: string;
 }

package/dist/api/types/ExportManifestPreviewResponse.d.ts

@@ -1,50 +1,63 @@
 export interface ExportManifestPreviewResponse {
-    counts?: ExportManifestPreviewResponse.Counts;
-    items?: ExportManifestPreviewResponse.Items;
+    /** Whether the preview completed successfully. */
+    success?: boolean;
+    /** Preview of assets that would be exported. */
+    preview?: ExportManifestPreviewResponse.Preview;
+    /** Error message if preview failed. */
+    error?: string;
 }
 export declare namespace ExportManifestPreviewResponse {
-    interface Counts {
-        rules?: number;
-        flows?: number;
-        contexts?: number;
-        values?: number;
+    /**
+     * Preview of assets that would be exported.
+     */
+    interface Preview {
+        counts?: Preview.Counts;
+        items?: Preview.Items;
     }
-    interface Items {
-        rules?: Items.Rules.Item[];
-        flows?: Items.Flows.Item[];
-        contexts?: Items.Contexts.Item[];
-        values?: Items.Values.Item[];
-    }
-    namespace Items {
-        type Rules = Rules.Item[];
-        namespace Rules {
-            interface Item {
-                id?: string;
-                name?: string;
-                slug?: string;
-            }
+    namespace Preview {
+        interface Counts {
+            rules?: number;
+            flows?: number;
+            contexts?: number;
+            values?: number;
         }
-        type Flows = Flows.Item[];
-        namespace Flows {
-            interface Item {
-                id?: string;
-                name?: string;
-                slug?: string;
-            }
+        interface Items {
+            rules?: Items.Rules.Item[];
+            flows?: Items.Flows.Item[];
+            contexts?: Items.Contexts.Item[];
+            values?: Items.Values.Item[];
         }
-        type Contexts = Contexts.Item[];
-        namespace Contexts {
-            interface Item {
-                id?: string;
-                name?: string;
-                slug?: string;
+        namespace Items {
+            type Rules = Rules.Item[];
+            namespace Rules {
+                interface Item {
+                    id?: string;
+                    name?: string;
+                    slug?: string;
+                }
             }
-        }
-        type Values = Values.Item[];
-        namespace Values {
-            interface Item {
-                id?: string;
-                name?: string;
+            type Flows = Flows.Item[];
+            namespace Flows {
+                interface Item {
+                    id?: string;
+                    name?: string;
+                    slug?: string;
+                }
+            }
+            type Contexts = Contexts.Item[];
+            namespace Contexts {
+                interface Item {
+                    id?: string;
+                    name?: string;
+                    slug?: string;
+                }
+            }
+            type Values = Values.Item[];
+            namespace Values {
+                interface Item {
+                    id?: string;
+                    name?: string;
+                }
             }
         }
     }

package/dist/api/types/ExportManifestResponse.d.ts

@@ -1,9 +1,30 @@
 export interface ExportManifestResponse {
-    /** Manifest format version. */
-    version?: string;
-    exported_at?: string;
-    rules?: Record<string, unknown>[];
-    flows?: Record<string, unknown>[];
-    contexts?: Record<string, unknown>[];
-    values?: Record<string, unknown>[];
+    /** Whether the export completed successfully. */
+    success?: boolean;
+    /** The exported manifest data. */
+    manifest?: ExportManifestResponse.Manifest;
+    /** Error message if export failed. */
+    error?: string;
+}
+export declare namespace ExportManifestResponse {
+    /**
+     * The exported manifest data.
+     */
+    interface Manifest {
+        /** Manifest format version. */
+        version?: string;
+        /** Manifest name. */
+        name?: string;
+        /** Manifest description. */
+        description?: string;
+        exported_at?: string;
+        /** Exported contexts. */
+        contexts?: Record<string, unknown>[];
+        /** Exported dynamic values. */
+        values?: Record<string, unknown>[];
+        /** Exported rules. */
+        rules?: Record<string, unknown>[];
+        /** Exported flows. */
+        flows?: Record<string, unknown>[];
+    }
 }

package/dist/api/types/Folder.d.ts

@@ -5,6 +5,10 @@ export interface Folder {
     name?: string;
     /** Description of the folder. */
     description?: string;
+    /** Timestamp of when the folder was created. */
+    created_at?: string;
     /** Timestamp of when the folder was last updated. */
     updated_at?: string;
+    /** User groups that can view this folder. */
+    user_groups?: string[];
 }

package/dist/api/types/ImportManifestResponse.d.ts

@@ -1,38 +1,66 @@
 export interface ImportManifestResponse {
-    /** Success message. */
-    message?: string;
-    /** Count of imported assets by type. */
-    imported?: ImportManifestResponse.Imported;
-    /** Count of skipped assets by type (already exist and overwrite=false). */
-    skipped?: ImportManifestResponse.Skipped;
+    /** Whether the import completed successfully. */
+    success?: boolean;
+    /** Assets that were created during import. */
+    created?: ImportManifestResponse.Created.Item[];
+    /** Assets that were updated during import. */
+    updated?: ImportManifestResponse.Updated.Item[];
+    /** Assets that were skipped during import. */
+    skipped?: ImportManifestResponse.Skipped.Item[];
     /** Any errors encountered during import. */
     errors?: ImportManifestResponse.Errors.Item[];
+    /** Non-fatal warnings from import validation. */
+    warnings?: string[];
+    /** IDs of any organizational folders created during import. */
+    organization_created?: ImportManifestResponse.OrganizationCreated | null;
 }
 export declare namespace ImportManifestResponse {
-    /**
-     * Count of imported assets by type.
-     */
-    interface Imported {
-        rules?: number;
-        flows?: number;
-        contexts?: number;
-        values?: number;
+    type Created = Created.Item[];
+    namespace Created {
+        interface Item {
+            /** Asset type (context, value, rule, flow, relationship). */
+            type?: string;
+            /** Stable ID of asset. */
+            stable_id?: string;
+            /** Database ID of asset. */
+            db_id?: string;
+            /** Import status. */
+            status?: string;
+        }
     }
-    /**
-     * Count of skipped assets by type (already exist and overwrite=false).
-     */
-    interface Skipped {
-        rules?: number;
-        flows?: number;
-        contexts?: number;
-        values?: number;
+    type Updated = Updated.Item[];
+    namespace Updated {
+        interface Item {
+            type?: string;
+            stable_id?: string;
+            db_id?: string;
+            status?: string;
+        }
+    }
+    type Skipped = Skipped.Item[];
+    namespace Skipped {
+        interface Item {
+            type?: string;
+            stable_id?: string;
+            status?: string;
+            reason?: string;
+        }
     }
     type Errors = Errors.Item[];
     namespace Errors {
         interface Item {
             type?: string;
-            id?: string;
-            error?: string;
+            stable_id?: string;
+            status?: string;
+            reason?: string;
         }
     }
+    /**
+     * IDs of any organizational folders created during import.
+     */
+    interface OrganizationCreated {
+        entity_set_id?: string | null;
+        rule_tag_id?: string | null;
+        flow_tag_id?: string | null;
+    }
 }

package/dist/api/types/RuleDetail.d.ts

@@ -4,12 +4,16 @@ export interface RuleDetail extends Rulebricks.RuleBase {
     created_at?: string;
     /** The date this rule was last updated. */
     updated_at?: string;
+    /** Whether the rule is currently published. */
+    published?: boolean;
+    /** Optional user-defined metadata for API-first integrations. */
+    metadata?: Record<string, unknown>;
     folder?: Rulebricks.Folder;
     /** The context this rule is bound to (if any). Rules bound to a context have their inputs/outputs mapped to context fields. */
     context?: RuleDetail.Context | null;
-    /** The published request schema for the rule. */
+    /** The request schema for the rule. Uses published schema when published, otherwise draft schema. */
     request_schema?: Rulebricks.SchemaField[];
-    /** The published response schema for the rule. */
+    /** The response schema for the rule. Uses published schema when published, otherwise draft schema. */
     response_schema?: Rulebricks.SchemaField[];
 }
 export declare namespace RuleDetail {

package/dist/api/types/RuleImportConditionRow.d.ts

@@ -0,0 +1,11 @@
+import type * as Rulebricks from "../index.js";
+/**
+ * A single rule row containing request conditions and response output.
+ */
+export interface RuleImportConditionRow {
+    /** Request-side cells keyed by request schema field key. */
+    request: Record<string, Rulebricks.RuleImportRequestCell>;
+    /** Response-side cells keyed by response schema field key. */
+    response: Record<string, Rulebricks.RuleImportResponseCell>;
+    settings: Rulebricks.RuleImportRowSettings;
+}

package/dist/api/types/RuleImportConditionRow.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/types/RuleImportPayload.d.ts

@@ -0,0 +1,60 @@
+import type * as Rulebricks from "../index.js";
+/**
+ * Rule object accepted by /admin/rules/import. Existing rule IDs allow partial updates; creating a new rule ID requires the full legacy import shape.
+ */
+export interface RuleImportPayload {
+    /** Rule ID to create or update. */
+    id: string;
+    /** Optional stable ID for cross-workspace import/export identity. */
+    stable_id?: string;
+    /** Rule slug. */
+    slug?: string;
+    /** Rule name. */
+    name?: string;
+    /** Rule description. */
+    description?: string;
+    /** Creation timestamp. */
+    createdAt?: string;
+    /** Last update timestamp. */
+    updatedAt?: string;
+    /** Current publish state. Set with `_publish`/`_unpublish` to control publish transitions on import. */
+    published?: boolean;
+    /** Optional user-defined metadata for external IDs or implementation mappings. */
+    metadata?: Record<string, unknown>;
+    /** If true, backend publishes this rule and snapshots published_* fields from draft fields. */
+    _publish?: boolean;
+    /** If true, backend unpublishes this rule. */
+    _unpublish?: boolean;
+    /** Draft request schema. */
+    requestSchema?: Rulebricks.RuleImportSchemaField[];
+    /** Draft response schema. */
+    responseSchema?: Rulebricks.RuleImportSchemaField[];
+    /** Sample request JSON. */
+    sampleRequest?: Record<string, unknown>;
+    /** Request payload used by editor test tab. */
+    testRequest?: Record<string, unknown>;
+    /** Sample response JSON. */
+    sampleResponse?: Record<string, unknown>;
+    /** Draft condition rows. */
+    conditions?: Rulebricks.RuleImportConditionRow[];
+    /** Optional row grouping definitions. */
+    groups?: Record<string, Record<string, unknown>>;
+    /** Optional rule-level settings. */
+    settings?: Record<string, unknown>;
+    /** Optional rule test suite. */
+    testSuite?: Record<string, unknown>[];
+    /** Rule history entries. */
+    history?: Record<string, unknown>[];
+    /** Publish timestamp. */
+    publishedAt?: string | null;
+    /** Optional published request schema override. */
+    published_requestSchema?: Rulebricks.RuleImportSchemaField[] | null;
+    /** Optional published response schema override. */
+    published_responseSchema?: Rulebricks.RuleImportSchemaField[] | null;
+    /** Optional published conditions override. */
+    published_conditions?: Rulebricks.RuleImportConditionRow[] | null;
+    /** Optional published groups override. */
+    published_groups?: Record<string, Record<string, unknown> | null> | null;
+    /** Accepts any additional properties */
+    [key: string]: any;
+}

package/dist/api/types/RuleImportPayload.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/types/RuleImportRequestCell.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A request cell in a condition row.
+ */
+export interface RuleImportRequestCell {
+    /** Operator name for this request comparison. */
+    op: string;
+    /** Operator arguments. */
+    args: unknown[];
+    /** Accepts any additional properties */
+    [key: string]: any;
+}

package/dist/api/types/RuleImportRequestCell.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/types/RuleImportResponseCell.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A response cell in a condition row.
+ */
+export interface RuleImportResponseCell {
+    value?: unknown;
+    /** Accepts any additional properties */
+    [key: string]: any;
+}

package/dist/api/types/RuleImportResponseCell.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/types/RuleImportRowSettings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Execution settings for a condition row.
+ */
+export interface RuleImportRowSettings {
+    /** Whether this row is active. */
+    enabled: boolean;
+    /** Optional group ID for grouped aggregation. */
+    groupId: string | null;
+    /** Row priority when multiple rows match. */
+    priority: number;
+    /** Optional schedule constraints for this row. */
+    schedule: Record<string, unknown>[];
+    /** When true, request cells in this row are evaluated with OR semantics. */
+    or?: boolean;
+    /** Accepts any additional properties */
+    [key: string]: any;
+}

package/dist/api/types/RuleImportRowSettings.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/types/RuleImportSchemaField.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A request or response schema field used when importing a rule.
+ */
+export interface RuleImportSchemaField {
+    /** Unique key for this field. */
+    key: string;
+    /** Whether this field is shown in the editor table. */
+    show: boolean;
+    /** Display name for this field. */
+    name: string;
+    /** Optional field description. */
+    description?: string;
+    /** Data type for this field. */
+    type: RuleImportSchemaField.Type;
+    /** Optional default value for this field. */
+    defaultValue?: unknown | null;
+    /** When true, this field should only accept values from a value collection. */
+    valuesOnly?: boolean;
+    /** Prefix used to scope available dynamic values for this field. */
+    valuesPrefix?: string;
+    /** Accepts any additional properties */
+    [key: string]: any;
+}
+export declare namespace RuleImportSchemaField {
+    /** Data type for this field. */
+    const Type: {
+        readonly String: "string";
+        readonly Number: "number";
+        readonly Boolean: "boolean";
+        readonly Date: "date";
+        readonly List: "list";
+        readonly Object: "object";
+        readonly Function: "function";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+}

package/dist/api/types/RuleImportSchemaField.js

@@ -0,0 +1,17 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleImportSchemaField = void 0;
+var RuleImportSchemaField;
+(function (RuleImportSchemaField) {
+    /** Data type for this field. */
+    RuleImportSchemaField.Type = {
+        String: "string",
+        Number: "number",
+        Boolean: "boolean",
+        Date: "date",
+        List: "list",
+        Object: "object",
+        Function: "function",
+    };
+})(RuleImportSchemaField || (exports.RuleImportSchemaField = RuleImportSchemaField = {}));

package/dist/api/types/SchemaField.d.ts

@@ -10,9 +10,9 @@ export interface SchemaField {
     /** Data type of this field. */
     type?: SchemaField.Type;
     /** Default value for this field. */
-    defaultValue?: SchemaField.DefaultValue | null;
+    default_value?: SchemaField.DefaultValue | null;
     /** Computed default value for this field. */
-    defaultComputedValue?: string | null;
+    default_computed_value?: string | null;
     /** Transformation expression to apply to this field. */
     transform?: string;
 }

package/dist/api/types/SolveContextFlowRequest.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Optional request body for executing a flow against context. The entire body is merged with instance state before flow execution.
+ */
+export type SolveContextFlowRequest = Record<string, unknown>;

package/dist/api/types/SolveContextFlowRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/types/SolveContextRuleRequest.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Optional request body for solving a rule against context. The entire body is merged with the instance state before rule evaluation.
+ */
+export type SolveContextRuleRequest = Record<string, unknown>;

package/dist/api/types/SolveContextRuleRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/types/Test.d.ts

@@ -9,14 +9,14 @@ export interface Test {
     response: Record<string, unknown>;
     /** Indicates whether the test is critical. */
     critical: boolean;
-    /** Indicates if the test resulted in an error. */
-    error: boolean;
-    /** Indicates if the test was successful. */
-    success: boolean;
+    /** Indicates if the test resulted in an error. Null if test has not been executed. */
+    error?: boolean | null;
+    /** Indicates if the test was successful. Null if test has not been executed. */
+    success?: boolean | null;
     /** The state of the test after execution. */
-    testState?: Test.TestState | null;
+    test_state?: Test.TestState | null;
     /** The timestamp when the test was last executed. */
-    lastExecuted?: string | null;
+    last_executed?: string | null;
 }
 export declare namespace Test {
     /**
@@ -29,10 +29,10 @@ export declare namespace Test {
         response?: Record<string, unknown> | null;
         conditions?: Record<string, unknown>[];
         /** HTTP status code returned */
-        httpStatus?: number;
-        successIdxs?: number[];
+        http_status?: number;
+        success_idxs?: number[];
         /** Error message or flag indicating if evaluation error occurred */
-        evaluationError?: TestState.EvaluationError;
+        evaluation_error?: TestState.EvaluationError;
     }
     namespace TestState {
         /**

package/dist/api/types/UpdateContextResponse.d.ts

@@ -1,2 +1,13 @@
-import type * as Rulebricks from "../index.js";
-export type UpdateContextResponse = Rulebricks.ContextDetail;
+/**
+ * Response after updating a context.
+ */
+export interface UpdateContextResponse {
+    /** The unique identifier of the updated context. */
+    id?: string;
+    /** The slug of the updated context. */
+    slug?: string;
+    /** The name of the updated context. */
+    name?: string;
+    /** Timestamp of when the context was updated. */
+    updated_at?: string;
+}

package/dist/api/types/UsageStatistics.d.ts

@@ -1,14 +1,20 @@
 export interface UsageStatistics {
     /** The current plan of the organization. */
     plan?: string;
-    /** The start date of the current monthly period. */
+    /** The start date of the current monthly period (MM-DD-YYYY). */
     monthly_period_start?: string;
-    /** The end date of the current monthly period. */
+    /** The end date of the current monthly period (MM-DD-YYYY). */
     monthly_period_end?: string;
     /** The number of rule executions used this month. */
     monthly_executions_usage?: number;
-    /** The total number of rule executions allowed this month. */
+    /** The total number of rule executions allowed this month. -1 indicates unlimited. */
     monthly_executions_limit?: number;
-    /** The number of rule executions remaining this month. */
+    /** The number of rule executions remaining this month. -1 indicates unlimited. */
     monthly_executions_remaining?: number;
+    /** Whether the plan has unlimited executions (true when monthly_executions_limit is -1). */
+    unlimited_plan?: boolean;
+    /** Number of days remaining in the current billing period. */
+    days_remaining_in_period?: number;
+    /** Average number of executions per day in the current period. */
+    daily_average_usage?: number;
 }

package/dist/api/types/UserGroup.d.ts

@@ -7,4 +7,6 @@ export interface UserGroup {
     description?: string;
     /** List of member emails in the user group. */
     members?: string[];
+    /** When the user group was created. */
+    created_at?: string;
 }