@epilot/sdk 2.18.13 → 2.18.15

package/dist/{validation-rules.d-Db5c5zTf.d.ts → validation-rules.d-BBy6Cw2O.d.ts}

@@ -1,12 +1,110 @@
 import { OpenAPIClient, Parameters, UnknownParamsObject, AxiosRequestConfig, OperationResponse } from 'openapi-client-axios';
 
 /* Auto-copied from validation-rules-client */
-/* eslint-disable */
-
 
 
 declare namespace Components {
     namespace Schemas {
+        /**
+         * Declarative validation rule (schema version v2). Supports predefined comparison operators
+         * over number, date and text inputs, with static, dynamic (context path) and relative-date
+         * comparison values.
+         *
+         */
+        export interface ComparisonRuleType {
+            /**
+             * The kind of input value the rule validates. Determines which operators are allowed.
+             */
+            input_type: "number" | "date" | "text";
+            /**
+             * The comparisons the input value must satisfy. All blocking conditions must pass
+             * for the input to be valid; `allow_failure` conditions are advisory and excluded
+             * from the verdict. Must contain at least one condition (enforced at write time).
+             *
+             */
+            conditions: /* A single comparison the input value must satisfy. */ Condition[];
+        }
+        /**
+         * A single comparison the input value must satisfy.
+         */
+        export interface Condition {
+            /**
+             * Stable identifier of the condition within the rule, used for editing and error reporting.
+             */
+            id: string;
+            operator: /**
+             * Predefined comparison operator. Compatibility (enforced at write time):
+             * - number: equal, notEqual, greaterThan, greaterThanInclusive, lessThan, lessThanInclusive, between, regexMatch
+             * - date: dateBefore, dateOnOrBefore, dateAfter, dateOnOrAfter, dateBetween, notInFuture, notInPast, regexMatch
+             * - text: equal, notEqual, contains, doesNotContain, startsWith, endsWith, regexMatch, lengthBetween,
+             *   greaterThan, greaterThanInclusive, lessThan, lessThanInclusive, between
+             * Range operators (between, dateBetween, lengthBetween) require a `range` value;
+             * unary operators (notInFuture, notInPast) require a `none` value; all others require a scalar value.
+             * regexMatch validates the raw input string's format and always takes a static string pattern.
+             * Numeric comparison operators on text rules parse the input as a number at evaluation time
+             * (free-text fields often hold numbers); unparsable input fails the condition.
+             *
+             */
+            Operator;
+            value: /* The comparison value of a condition - a scalar, a range of scalars, or nothing (unary operators). */ ConditionValue;
+            /**
+             * Message shown to the end user when this condition fails.
+             */
+            error_message: string;
+            /**
+             * When true, the condition is advisory: it is always evaluated and reported
+             * when it fails, but it never takes part in the validity verdict.
+             * The input is valid when every blocking (non-advisory) condition passes.
+             * A rule whose conditions are all advisory is always valid (warnings only).
+             *
+             */
+            allow_failure?: boolean;
+        }
+        /**
+         * The comparison value of a condition - a scalar, a range of scalars, or nothing (unary operators).
+         */
+        export type ConditionValue = /* The comparison value of a condition - a scalar, a range of scalars, or nothing (unary operators). */ /* A fixed comparison value. */ StaticValue | /**
+         * A dynamic comparison value resolved from runtime context, e.g. `contract.installment_amount`
+         * or `previous_reading.value`. The first path segment must match the `name` of a declared
+         * context requirement.
+         *
+         */
+        ContextValue | /* A date relative to the evaluation moment, e.g. "today minus 30 days". Only valid for date rules. */ RelativeDateValue | /* A lower and upper bound for range operators (between, dateBetween, lengthBetween). Bounds are inclusive. */ RangeValue | /* No comparison value - used by unary operators such as notInFuture / notInPast. */ NoValue;
+        /**
+         * An entity context source the rule needs at evaluation time, referenced by `context`
+         * value paths via the schema slug as their first segment (e.g. `contract.installment_amount`).
+         * How the source is resolved (which entity instance) is decided by the consuming surface,
+         * not by the rule. Meter reading comparisons use the meter/meter_counter entity schemas
+         * (e.g. `meter_counter.current_consumption` for the previous reading value).
+         *
+         */
+        export interface ContextRequirement {
+            /**
+             * Entity schema slug.
+             * example:
+             * contract
+             */
+            schema: string;
+        }
+        /**
+         * A dynamic comparison value resolved from runtime context, e.g. `contract.installment_amount`
+         * or `previous_reading.value`. The first path segment must match the `name` of a declared
+         * context requirement.
+         *
+         */
+        export interface ContextValue {
+            source: "context";
+            /**
+             * Dot-separated path into the resolved context.
+             */
+            path: string; // ^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z0-9_]+)*$
+            adjust?: /**
+             * Adjusts a context-resolved numeric value before comparison, e.g. "context value plus 10 percent".
+             * Used to express tolerance bands such as "at most 10% above the current instalment amount".
+             *
+             */
+            ValueAdjustment;
+        }
         export interface CreateValidationRuleRequest {
             /**
              * Title of the validation rule.
@@ -19,12 +117,53 @@ declare namespace Components {
             /**
              * Describes where and how a validation rule is applied.
              */
-            used_by?: /* Describes where and how a validation rule is applied. */ UsedBy[];
-            rule: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType;
+            used_by?: /**
+             * Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.
+             * example:
+             * {
+             *   "type": "journey",
+             *   "source_id": "journey-xyz789"
+             * }
+             */
+            UsedBy[];
+            rule: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType | /**
+             * Declarative validation rule (schema version v2). Supports predefined comparison operators
+             * over number, date and text inputs, with static, dynamic (context path) and relative-date
+             * comparison values.
+             *
+             */
+            ComparisonRuleType;
+            /**
+             * Declares the dynamic context a v2 rule needs at evaluation time.
+             * `context` condition values reference these sources by using the schema slug
+             * as the first segment of their `path`. Only applicable to v2 rules.
+             *
+             */
+            contexts?: /**
+             * An entity context source the rule needs at evaluation time, referenced by `context`
+             * value paths via the schema slug as their first segment (e.g. `contract.installment_amount`).
+             * How the source is resolved (which entity instance) is decided by the consuming surface,
+             * not by the rule. Meter reading comparisons use the meter/meter_counter entity schemas
+             * (e.g. `meter_counter.current_consumption` for the previous reading value).
+             *
+             */
+            ContextRequirement[];
         }
+        /**
+         * Response envelope for listing all validation rules within an organization.
+         */
         export interface GetValidationRulesResponse {
+            /**
+             * Flat list of all validation rules belonging to the authenticated organization.
+             */
             results?: /* The Validation rule definition. */ ValidationRule[];
         }
+        /**
+         * No comparison value - used by unary operators such as notInFuture / notInPast.
+         */
+        export interface NoValue {
+            source: "none";
+        }
         /**
          * Condition definition for a numeric-based validation rule (2 levels deep)
          */
@@ -154,6 +293,20 @@ declare namespace Components {
              */
             conditions: /* Condition definition for a numeric-based validation rule (2 levels deep) */ NumericCondition;
         }
+        /**
+         * Predefined comparison operator. Compatibility (enforced at write time):
+         * - number: equal, notEqual, greaterThan, greaterThanInclusive, lessThan, lessThanInclusive, between, regexMatch
+         * - date: dateBefore, dateOnOrBefore, dateAfter, dateOnOrAfter, dateBetween, notInFuture, notInPast, regexMatch
+         * - text: equal, notEqual, contains, doesNotContain, startsWith, endsWith, regexMatch, lengthBetween,
+         *   greaterThan, greaterThanInclusive, lessThan, lessThanInclusive, between
+         * Range operators (between, dateBetween, lengthBetween) require a `range` value;
+         * unary operators (notInFuture, notInPast) require a `none` value; all others require a scalar value.
+         * regexMatch validates the raw input string's format and always takes a static string pattern.
+         * Numeric comparison operators on text rules parse the input as a number at evaluation time
+         * (free-text fields often hold numbers); unparsable input fails the condition.
+         *
+         */
+        export type Operator = "equal" | "notEqual" | "greaterThan" | "greaterThanInclusive" | "lessThan" | "lessThanInclusive" | "between" | "dateBefore" | "dateOnOrBefore" | "dateAfter" | "dateOnOrAfter" | "dateBetween" | "notInFuture" | "notInPast" | "contains" | "doesNotContain" | "startsWith" | "endsWith" | "regexMatch" | "lengthBetween";
         /**
          * Condition definition for a pattern-based validation rule (2 levels deep)
          */
@@ -311,6 +464,14 @@ declare namespace Components {
              */
             conditions: /* Condition definition for a pattern-based validation rule (2 levels deep) */ PatternCondition;
         }
+        /**
+         * A lower and upper bound for range operators (between, dateBetween, lengthBetween). Bounds are inclusive.
+         */
+        export interface RangeValue {
+            source: "range";
+            min: /* A single comparison value - static, resolved from context, or a relative date. */ ScalarValue;
+            max: /* A single comparison value - static, resolved from context, or a relative date. */ ScalarValue;
+        }
         /**
          * Condition definition for a regex-based validation rule (2 levels deep)
          */
@@ -370,6 +531,38 @@ declare namespace Components {
              */
             conditions: /* Condition definition for a regex-based validation rule (2 levels deep) */ RegexCondition;
         }
+        /**
+         * A date relative to the evaluation moment, e.g. "today minus 30 days". Only valid for date rules.
+         */
+        export interface RelativeDateValue {
+            source: "relative_date";
+            /**
+             * Offset from the anchor. Negative values are in the past, positive in the future, 0 is the anchor itself.
+             */
+            offset: number;
+            unit: "days" | "months" | "years";
+            anchor?: "today";
+        }
+        /**
+         * A single comparison value - static, resolved from context, or a relative date.
+         */
+        export type ScalarValue = /* A single comparison value - static, resolved from context, or a relative date. */ /* A fixed comparison value. */ StaticValue | /**
+         * A dynamic comparison value resolved from runtime context, e.g. `contract.installment_amount`
+         * or `previous_reading.value`. The first path segment must match the `name` of a declared
+         * context requirement.
+         *
+         */
+        ContextValue | /* A date relative to the evaluation moment, e.g. "today minus 30 days". Only valid for date rules. */ RelativeDateValue;
+        /**
+         * A fixed comparison value.
+         */
+        export interface StaticValue {
+            source: "static";
+            /**
+             * The literal value. Numbers for numeric comparisons, ISO 8601 date strings for date comparisons, strings for text comparisons.
+             */
+            data: /* The literal value. Numbers for numeric comparisons, ISO 8601 date strings for date comparisons, strings for text comparisons. */ number | string | boolean;
+        }
         export interface UpdateValidationRuleRequest {
             /**
              * Title of the validation rule.
@@ -382,23 +575,63 @@ declare namespace Components {
             /**
              * Describes where and how a validation rule is applied.
              */
-            used_by?: /* Describes where and how a validation rule is applied. */ UsedBy[];
-            rule?: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType;
+            used_by?: /**
+             * Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.
+             * example:
+             * {
+             *   "type": "journey",
+             *   "source_id": "journey-xyz789"
+             * }
+             */
+            UsedBy[];
+            rule?: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType | /**
+             * Declarative validation rule (schema version v2). Supports predefined comparison operators
+             * over number, date and text inputs, with static, dynamic (context path) and relative-date
+             * comparison values.
+             *
+             */
+            ComparisonRuleType;
+            /**
+             * Declares the dynamic context a v2 rule needs at evaluation time.
+             * `context` condition values reference these sources by using the schema slug
+             * as the first segment of their `path`. Only applicable to v2 rules.
+             *
+             */
+            contexts?: /**
+             * An entity context source the rule needs at evaluation time, referenced by `context`
+             * value paths via the schema slug as their first segment (e.g. `contract.installment_amount`).
+             * How the source is resolved (which entity instance) is decided by the consuming surface,
+             * not by the rule. Meter reading comparisons use the meter/meter_counter entity schemas
+             * (e.g. `meter_counter.current_consumption` for the previous reading value).
+             *
+             */
+            ContextRequirement[];
         }
         /**
-         * Describes where and how a validation rule is applied.
+         * Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.
+         * example:
+         * {
+         *   "type": "journey",
+         *   "source_id": "journey-xyz789"
+         * }
          */
         export interface UsedBy {
             /**
-             * The context in which the rule is used (e.g., journey or entity).
+             * The context in which the rule is used - either a journey block or an entity schema attribute.
+             * example:
+             * journey
              */
             type: "journey" | "entity";
             /**
-             * Slug of the schema using this rule for entities.
+             * Slug of the entity schema using this rule. Only applicable when `type` is `entity`.
+             * example:
+             * contact
              */
             schema_slug?: string;
             /**
-             * Source identifier for the usage context.
+             * Unique identifier of the source (e.g. journey ID or entity attribute key) that references this rule.
+             * example:
+             * journey-xyz789
              */
             source_id?: string;
         }
@@ -417,8 +650,37 @@ declare namespace Components {
             /**
              * Describes where and how a validation rule is applied.
              */
-            used_by?: /* Describes where and how a validation rule is applied. */ UsedBy[];
-            rule?: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType;
+            used_by?: /**
+             * Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.
+             * example:
+             * {
+             *   "type": "journey",
+             *   "source_id": "journey-xyz789"
+             * }
+             */
+            UsedBy[];
+            rule?: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType | /**
+             * Declarative validation rule (schema version v2). Supports predefined comparison operators
+             * over number, date and text inputs, with static, dynamic (context path) and relative-date
+             * comparison values.
+             *
+             */
+            ComparisonRuleType;
+            /**
+             * Declares the dynamic context a v2 rule needs at evaluation time.
+             * `context` condition values reference these sources by using the schema slug
+             * as the first segment of their `path`. Only applicable to v2 rules.
+             *
+             */
+            contexts?: /**
+             * An entity context source the rule needs at evaluation time, referenced by `context`
+             * value paths via the schema slug as their first segment (e.g. `contract.installment_amount`).
+             * How the source is resolved (which entity instance) is decided by the consuming surface,
+             * not by the rule. Meter reading comparisons use the meter/meter_counter entity schemas
+             * (e.g. `meter_counter.current_consumption` for the previous reading value).
+             *
+             */
+            ContextRequirement[];
             /**
              * Schema version of the validation rule.
              */
@@ -460,8 +722,47 @@ declare namespace Components {
             /**
              * Describes where and how a validation rule is applied.
              */
-            used_by?: /* Describes where and how a validation rule is applied. */ UsedBy[];
-            rule?: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType;
+            used_by?: /**
+             * Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.
+             * example:
+             * {
+             *   "type": "journey",
+             *   "source_id": "journey-xyz789"
+             * }
+             */
+            UsedBy[];
+            rule?: /* Validation rule that uses a regular expression to validate input. */ RegexRuleType | /* Validation rule that uses a sequence of patterns to validate input. */ PatternRuleType | /* Validation rule for numeric values, supporting range and digit count constraints. */ NumericRuleType | /**
+             * Declarative validation rule (schema version v2). Supports predefined comparison operators
+             * over number, date and text inputs, with static, dynamic (context path) and relative-date
+             * comparison values.
+             *
+             */
+            ComparisonRuleType;
+            /**
+             * Declares the dynamic context a v2 rule needs at evaluation time.
+             * `context` condition values reference these sources by using the schema slug
+             * as the first segment of their `path`. Only applicable to v2 rules.
+             *
+             */
+            contexts?: /**
+             * An entity context source the rule needs at evaluation time, referenced by `context`
+             * value paths via the schema slug as their first segment (e.g. `contract.installment_amount`).
+             * How the source is resolved (which entity instance) is decided by the consuming surface,
+             * not by the rule. Meter reading comparisons use the meter/meter_counter entity schemas
+             * (e.g. `meter_counter.current_consumption` for the previous reading value).
+             *
+             */
+            ContextRequirement[];
+        }
+        /**
+         * Adjusts a context-resolved numeric value before comparison, e.g. "context value plus 10 percent".
+         * Used to express tolerance bands such as "at most 10% above the current instalment amount".
+         *
+         */
+        export interface ValueAdjustment {
+            type: "percent" | "absolute";
+            value: number;
+            direction: "increase" | "decrease";
         }
     }
 }
@@ -473,7 +774,15 @@ declare namespace Paths {
         export interface PathParameters {
             ruleId: Parameters.RuleId;
         }
-        export type RequestBody = /* Describes where and how a validation rule is applied. */ Components.Schemas.UsedBy;
+        export type RequestBody = /**
+         * Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.
+         * example:
+         * {
+         *   "type": "journey",
+         *   "source_id": "journey-xyz789"
+         * }
+         */
+        Components.Schemas.UsedBy;
         namespace Responses {
             export type $200 = /* The Validation rule definition. */ Components.Schemas.ValidationRule;
             export interface $400 {
@@ -483,6 +792,20 @@ declare namespace Paths {
                  */
                 message?: string;
             }
+            export interface $401 {
+                /**
+                 * example:
+                 * Unauthorized
+                 */
+                message?: string;
+            }
+            export interface $403 {
+                /**
+                 * example:
+                 * Forbidden
+                 */
+                message?: string;
+            }
             export interface $404 {
                 /**
                  * example:
@@ -503,6 +826,34 @@ declare namespace Paths {
         export type RequestBody = Components.Schemas.CreateValidationRuleRequest;
         namespace Responses {
             export type $201 = /* The Validation rule definition. */ Components.Schemas.ValidationRule;
+            export interface $400 {
+                /**
+                 * example:
+                 * Invalid request body
+                 */
+                message?: string;
+            }
+            export interface $401 {
+                /**
+                 * example:
+                 * Unauthorized
+                 */
+                message?: string;
+            }
+            export interface $403 {
+                /**
+                 * example:
+                 * Forbidden
+                 */
+                message?: string;
+            }
+            export interface $500 {
+                /**
+                 * example:
+                 * Unknown API Error
+                 */
+                message?: string;
+            }
         }
     }
     namespace DeleteValidationRule {
@@ -515,6 +866,27 @@ declare namespace Paths {
         namespace Responses {
             export interface $204 {
             }
+            export interface $401 {
+                /**
+                 * example:
+                 * Unauthorized
+                 */
+                message?: string;
+            }
+            export interface $403 {
+                /**
+                 * example:
+                 * Forbidden
+                 */
+                message?: string;
+            }
+            export interface $404 {
+                /**
+                 * example:
+                 * Validation rule not found
+                 */
+                message?: string;
+            }
             export interface $500 {
                 /**
                  * example:
@@ -533,6 +905,20 @@ declare namespace Paths {
         }
         namespace Responses {
             export type $200 = /* The Validation rule definition. */ Components.Schemas.ValidationRule;
+            export interface $401 {
+                /**
+                 * example:
+                 * Unauthorized
+                 */
+                message?: string;
+            }
+            export interface $403 {
+                /**
+                 * example:
+                 * Forbidden
+                 */
+                message?: string;
+            }
             export interface $404 {
                 /**
                  * example:
@@ -551,7 +937,7 @@ declare namespace Paths {
     }
     namespace GetValidationRules {
         namespace Responses {
-            export type $200 = Components.Schemas.GetValidationRulesResponse;
+            export type $200 = /* Response envelope for listing all validation rules within an organization. */ Components.Schemas.GetValidationRulesResponse;
             export interface $400 {
                 /**
                  * example:
@@ -559,6 +945,20 @@ declare namespace Paths {
                  */
                 message?: string;
             }
+            export interface $401 {
+                /**
+                 * example:
+                 * Unauthorized
+                 */
+                message?: string;
+            }
+            export interface $403 {
+                /**
+                 * example:
+                 * Forbidden
+                 */
+                message?: string;
+            }
             export interface $500 {
                 /**
                  * example:
@@ -575,7 +975,15 @@ declare namespace Paths {
         export interface PathParameters {
             ruleId: Parameters.RuleId;
         }
-        export type RequestBody = /* Describes where and how a validation rule is applied. */ Components.Schemas.UsedBy;
+        export type RequestBody = /**
+         * Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.
+         * example:
+         * {
+         *   "type": "journey",
+         *   "source_id": "journey-xyz789"
+         * }
+         */
+        Components.Schemas.UsedBy;
         namespace Responses {
             export type $200 = /* The Validation rule definition. */ Components.Schemas.ValidationRule;
             export interface $400 {
@@ -585,6 +993,20 @@ declare namespace Paths {
                  */
                 message?: string;
             }
+            export interface $401 {
+                /**
+                 * example:
+                 * Unauthorized
+                 */
+                message?: string;
+            }
+            export interface $403 {
+                /**
+                 * example:
+                 * Forbidden
+                 */
+                message?: string;
+            }
             export interface $404 {
                 /**
                  * example:
@@ -618,6 +1040,27 @@ declare namespace Paths {
                  */
                 message?: string;
             }
+            export interface $401 {
+                /**
+                 * example:
+                 * Unauthorized
+                 */
+                message?: string;
+            }
+            export interface $403 {
+                /**
+                 * example:
+                 * Forbidden
+                 */
+                message?: string;
+            }
+            export interface $404 {
+                /**
+                 * example:
+                 * Validation rule not found
+                 */
+                message?: string;
+            }
             export interface $500 {
                 /**
                  * example:
@@ -632,9 +1075,12 @@ declare namespace Paths {
 
 interface OperationMethods {
   /**
-   * getValidationRules - Get all validation rules by organization Id
+   * getValidationRules - getValidationRules
+   * 
+   * Returns all validation rules belonging to the authenticated user's organization.
+   * 
+   * Results are returned as a flat list. Use this endpoint to list available rules when configuring journeys or entity schemas.
    * 
-   * Gets all validation rules by organization Id
    */
   'getValidationRules'(
     parameters?: Parameters<UnknownParamsObject> | null,
@@ -642,9 +1088,9 @@ interface OperationMethods {
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.GetValidationRules.Responses.$200>
   /**
-   * createValidationRule - Create Validation Rule
+   * createValidationRule - createValidationRule
    * 
-   * Creates a new validation rule
+   * Creates a new validation rule for the authenticated organization.
    */
   'createValidationRule'(
     parameters?: Parameters<UnknownParamsObject> | null,
@@ -652,9 +1098,9 @@ interface OperationMethods {
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.CreateValidationRule.Responses.$201>
   /**
-   * getValidationRuleById - Get validation rule by ID
+   * getValidationRuleById - getValidationRuleById
    * 
-   * Retrieves a specific validation rule by its ID
+   * Retrieves a specific validation rule by its unique ID.
    */
   'getValidationRuleById'(
     parameters?: Parameters<Paths.GetValidationRuleById.PathParameters> | null,
@@ -662,9 +1108,9 @@ interface OperationMethods {
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.GetValidationRuleById.Responses.$200>
   /**
-   * updateValidationRule - Update Validation Rule (partial update)
+   * updateValidationRule - updateValidationRule
    * 
-   * Updates an existing validation rule partially by ID
+   * Partially updates an existing validation rule by ID. Only the fields provided in the request body are updated.
    */
   'updateValidationRule'(
     parameters?: Parameters<Paths.UpdateValidationRule.PathParameters> | null,
@@ -672,9 +1118,9 @@ interface OperationMethods {
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.UpdateValidationRule.Responses.$200>
   /**
-   * deleteValidationRule - Delete Validation Rule
+   * deleteValidationRule - deleteValidationRule
    * 
-   * Deletes a validation rule by ID
+   * Permanently deletes a validation rule by ID. Any journeys or entity attributes referencing this rule should be updated before deletion.
    */
   'deleteValidationRule'(
     parameters?: Parameters<Paths.DeleteValidationRule.PathParameters> | null,
@@ -682,9 +1128,12 @@ interface OperationMethods {
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.DeleteValidationRule.Responses.$204>
   /**
-   * addUsedByReference - Add a reference to the usedBy array
+   * addUsedByReference - addUsedByReference
+   * 
+   * Adds a single `used_by` reference to an existing validation rule.
+   * 
+   * Use this endpoint when attaching a validation rule to a journey block or entity attribute to track where the rule is applied.
    * 
-   * Adds a single reference to the usedBy array of a validation rule
    */
   'addUsedByReference'(
     parameters?: Parameters<Paths.AddUsedByReference.PathParameters> | null,
@@ -692,9 +1141,12 @@ interface OperationMethods {
     config?: AxiosRequestConfig  
   ): OperationResponse<Paths.AddUsedByReference.Responses.$200>
   /**
-   * removeUsedByReference - Remove a reference from the usedBy array
+   * removeUsedByReference - removeUsedByReference
+   * 
+   * Removes a specific `used_by` reference from an existing validation rule.
+   * 
+   * Use this endpoint when detaching a validation rule from a journey block or entity attribute.
    * 
-   * Removes a specific reference from the usedBy array of a validation rule
    */
   'removeUsedByReference'(
     parameters?: Parameters<Paths.RemoveUsedByReference.PathParameters> | null,
@@ -706,9 +1158,12 @@ interface OperationMethods {
 interface PathsDictionary {
   ['/v1/validation-rules']: {
     /**
-     * getValidationRules - Get all validation rules by organization Id
+     * getValidationRules - getValidationRules
+     * 
+     * Returns all validation rules belonging to the authenticated user's organization.
+     * 
+     * Results are returned as a flat list. Use this endpoint to list available rules when configuring journeys or entity schemas.
      * 
-     * Gets all validation rules by organization Id
      */
     'get'(
       parameters?: Parameters<UnknownParamsObject> | null,
@@ -716,9 +1171,9 @@ interface PathsDictionary {
       config?: AxiosRequestConfig  
     ): OperationResponse<Paths.GetValidationRules.Responses.$200>
     /**
-     * createValidationRule - Create Validation Rule
+     * createValidationRule - createValidationRule
      * 
-     * Creates a new validation rule
+     * Creates a new validation rule for the authenticated organization.
      */
     'post'(
       parameters?: Parameters<UnknownParamsObject> | null,
@@ -728,9 +1183,9 @@ interface PathsDictionary {
   }
   ['/v1/validation-rules/{ruleId}']: {
     /**
-     * getValidationRuleById - Get validation rule by ID
+     * getValidationRuleById - getValidationRuleById
      * 
-     * Retrieves a specific validation rule by its ID
+     * Retrieves a specific validation rule by its unique ID.
      */
     'get'(
       parameters?: Parameters<Paths.GetValidationRuleById.PathParameters> | null,
@@ -738,9 +1193,9 @@ interface PathsDictionary {
       config?: AxiosRequestConfig  
     ): OperationResponse<Paths.GetValidationRuleById.Responses.$200>
     /**
-     * updateValidationRule - Update Validation Rule (partial update)
+     * updateValidationRule - updateValidationRule
      * 
-     * Updates an existing validation rule partially by ID
+     * Partially updates an existing validation rule by ID. Only the fields provided in the request body are updated.
      */
     'patch'(
       parameters?: Parameters<Paths.UpdateValidationRule.PathParameters> | null,
@@ -748,9 +1203,9 @@ interface PathsDictionary {
       config?: AxiosRequestConfig  
     ): OperationResponse<Paths.UpdateValidationRule.Responses.$200>
     /**
-     * deleteValidationRule - Delete Validation Rule
+     * deleteValidationRule - deleteValidationRule
      * 
-     * Deletes a validation rule by ID
+     * Permanently deletes a validation rule by ID. Any journeys or entity attributes referencing this rule should be updated before deletion.
      */
     'delete'(
       parameters?: Parameters<Paths.DeleteValidationRule.PathParameters> | null,
@@ -760,9 +1215,12 @@ interface PathsDictionary {
   }
   ['/v1/validation-rules/{ruleId}/used-by']: {
     /**
-     * addUsedByReference - Add a reference to the usedBy array
+     * addUsedByReference - addUsedByReference
+     * 
+     * Adds a single `used_by` reference to an existing validation rule.
+     * 
+     * Use this endpoint when attaching a validation rule to a journey block or entity attribute to track where the rule is applied.
      * 
-     * Adds a single reference to the usedBy array of a validation rule
      */
     'post'(
       parameters?: Parameters<Paths.AddUsedByReference.PathParameters> | null,
@@ -770,9 +1228,12 @@ interface PathsDictionary {
       config?: AxiosRequestConfig  
     ): OperationResponse<Paths.AddUsedByReference.Responses.$200>
     /**
-     * removeUsedByReference - Remove a reference from the usedBy array
+     * removeUsedByReference - removeUsedByReference
+     * 
+     * Removes a specific `used_by` reference from an existing validation rule.
+     * 
+     * Use this endpoint when detaching a validation rule from a journey block or entity attribute.
      * 
-     * Removes a specific reference from the usedBy array of a validation rule
      */
     'delete'(
       parameters?: Parameters<Paths.RemoveUsedByReference.PathParameters> | null,
@@ -785,23 +1246,35 @@ interface PathsDictionary {
 type Client = OpenAPIClient<OperationMethods, PathsDictionary>
 
 
+type ComparisonRuleType = Components.Schemas.ComparisonRuleType;
+type Condition = Components.Schemas.Condition;
+type ConditionValue = Components.Schemas.ConditionValue;
+type ContextRequirement = Components.Schemas.ContextRequirement;
+type ContextValue = Components.Schemas.ContextValue;
 type CreateValidationRuleRequest = Components.Schemas.CreateValidationRuleRequest;
 type GetValidationRulesResponse = Components.Schemas.GetValidationRulesResponse;
+type NoValue = Components.Schemas.NoValue;
 type NumericCondition = Components.Schemas.NumericCondition;
 type NumericFactCondition = Components.Schemas.NumericFactCondition;
 type NumericNestedCondition = Components.Schemas.NumericNestedCondition;
 type NumericRuleType = Components.Schemas.NumericRuleType;
+type Operator = Components.Schemas.Operator;
 type PatternCondition = Components.Schemas.PatternCondition;
 type PatternFactCondition = Components.Schemas.PatternFactCondition;
 type PatternNestedCondition = Components.Schemas.PatternNestedCondition;
 type PatternRuleType = Components.Schemas.PatternRuleType;
+type RangeValue = Components.Schemas.RangeValue;
 type RegexCondition = Components.Schemas.RegexCondition;
 type RegexFactCondition = Components.Schemas.RegexFactCondition;
 type RegexNestedCondition = Components.Schemas.RegexNestedCondition;
 type RegexRuleType = Components.Schemas.RegexRuleType;
+type RelativeDateValue = Components.Schemas.RelativeDateValue;
+type ScalarValue = Components.Schemas.ScalarValue;
+type StaticValue = Components.Schemas.StaticValue;
 type UpdateValidationRuleRequest = Components.Schemas.UpdateValidationRuleRequest;
 type UsedBy = Components.Schemas.UsedBy;
 type ValidationRule = Components.Schemas.ValidationRule;
 type ValidationRuleBase = Components.Schemas.ValidationRuleBase;
+type ValueAdjustment = Components.Schemas.ValueAdjustment;
 
-export { type Client as C, type GetValidationRulesResponse as G, type NumericCondition as N, type OperationMethods as O, Paths as P, type RegexCondition as R, type UpdateValidationRuleRequest as U, type ValidationRule as V, Components as a, type PathsDictionary as b, type CreateValidationRuleRequest as c, type NumericFactCondition as d, type NumericNestedCondition as e, type NumericRuleType as f, type PatternCondition as g, type PatternFactCondition as h, type PatternNestedCondition as i, type PatternRuleType as j, type RegexFactCondition as k, type RegexNestedCondition as l, type RegexRuleType as m, type UsedBy as n, type ValidationRuleBase as o };
+export { type Client as C, type GetValidationRulesResponse as G, type NoValue as N, type OperationMethods as O, Paths as P, type RangeValue as R, type ScalarValue as S, type UpdateValidationRuleRequest as U, type ValidationRule as V, Components as a, type PathsDictionary as b, type ComparisonRuleType as c, type Condition as d, type ConditionValue as e, type ContextRequirement as f, type ContextValue as g, type CreateValidationRuleRequest as h, type NumericCondition as i, type NumericFactCondition as j, type NumericNestedCondition as k, type NumericRuleType as l, type Operator as m, type PatternCondition as n, type PatternFactCondition as o, type PatternNestedCondition as p, type PatternRuleType as q, type RegexCondition as r, type RegexFactCondition as s, type RegexNestedCondition as t, type RegexRuleType as u, type RelativeDateValue as v, type StaticValue as w, type UsedBy as x, type ValidationRuleBase as y, type ValueAdjustment as z };