@kortexya/reasoninglayer 1.23.0 → 1.24.0

package/dist/index.d.ts

@@ -109,7 +109,7 @@ type JsonValue$1 = string | number | boolean | null | JsonValue$1[] | object;
  * This is the single source of truth for the version constant.
  * The `scripts/release.sh` script updates this value alongside `package.json`.
  */
-declare const SDK_VERSION = "1.23.0";
+declare const SDK_VERSION = "1.24.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -764,11 +764,12 @@ interface AddRuleRequest$1 {
      */
     antecedents?: TermInputDto$1[];
     /**
-     * Certainty factor (default: 1.0)
+     * Certainty factor. `None` (absent) is a crisp rule — degree 1.0; an
+     * explicit `0.0` is the t-norm annihilator, a rule that can never
+     * contribute a proof. The two are distinct on the wire (#217).
      * @format double
-     * @default 1
      */
-    certainty?: number;
+    certainty?: number | null;
     /** The conclusion term (head of the rule) */
     term: TermInputDto$1;
 }
@@ -11354,6 +11355,8 @@ type FeatureInputValueDto$1 = {
 } | {
     /** @format uuid */
     sort_ref: string;
+} | {
+    type: string;
 } | {
     name: string;
 } | {
@@ -11852,7 +11855,11 @@ interface ForwardChainRequest$1 {
      * Default: false (standard symbolic-only forward chaining)
      */
     enable_provenance_tags?: boolean;
-    /** Initial facts (optional - uses existing facts if not provided) */
+    /**
+     * Initial facts (optional). The run's fact universe is the union of the
+     * tenant's (gateway-visible) existing facts and these seeds, so a seed
+     * AUGMENTS the base — it never replaces it (#218).
+     */
     initial_facts?: TermInputDto$1[];
     /**
      * Maximum facts to derive
@@ -19792,34 +19799,21 @@ interface Objective$1 {
 }
 /** Direction of the objective function. */
 type ObjectiveSense$1 = "minimize" | "maximize";
-/** One observation on the wire. */
+/** One observed unit. */
 interface ObservationDto$1 {
+    /** Binary treatment indicator (`true` = treated). */
+    a: boolean;
     /**
-     * Sightings so far.
-     * @format int64
-     * @min 0
-     */
-    count: number;
-    /** Distinct source documents. */
-    documents: string[];
-    /**
-     * Unix seconds of the first sighting.
+     * Discrete covariate stratum (integer code — bin a categorical or
+     * coarsened-continuous confounder).
      * @format int64
      */
-    first_seen: number;
+    x: number;
     /**
-     * Unix seconds of the latest sighting.
-     * @format int64
+     * Observed outcome.
+     * @format double
      */
-    last_seen: number;
-    /** The normalised identity observations aggregate under. */
-    normalized: string;
-    /** Who saw it (`ingestion`, `extraction_certificate`, `sentinel_near_miss`). */
-    producers: string[];
-    /** The proposed sort's id, once a generate pass minted one. */
-    proposed_sort_id?: string | null;
-    /** Representative surface form. */
-    surface: string;
+    y: number;
 }
 /** Observational inputs for PN / PS */
 interface ObservationalProbabilitiesDto$1 {
@@ -19842,7 +19836,7 @@ interface ObservationalProbabilitiesDto$1 {
 /** Response of `GET /api/v1/sorts/proposals`. */
 interface ObservationsResponse {
     /** Observations, most recurrent first. */
-    observations: ObservationDto$1[];
+    observations: SightingDto[];
 }
 interface ObserveMultiRequest$1 {
     /** Map of variable name to value */
@@ -23199,6 +23193,35 @@ interface RepairHintDto {
     /** The feature or predicate the hint applies to. */
     target: string;
 }
+/**
+ * Response of `PUT /api/v1/inference/rules/{id}`.
+ *
+ * ## Why two ids
+ *
+ * A rule's id **is** its head term id. Under `OSFKB_RULE_STABLE_IDS=1` that id
+ * is content-addressed, so an edit that changes the head changes the id by
+ * construction; under the default it is random, so a replacement changes it
+ * anyway. There is no identity under which an edited rule is the same rule, so
+ * the response names both: the id that was withdrawn, and the id that now
+ * holds the edited clause. A client holding the old id must adopt the new one.
+ */
+interface ReplaceRuleResponse$1 {
+    /** How the edit moved the rule base's guarantees. */
+    certification: RuleCertificationDeltaDto;
+    /**
+     * The id the rule had before the edit. Every durable reference to it —
+     * `derived_facts.rule_id`, each `proofs[].rule_id`, queued dataflow
+     * events — was retracted rather than migrated: a conclusion proved by the
+     * pre-edit clause is not proved by the post-edit one, which is the point
+     * of the edit.
+     * @format uuid
+     */
+    previous_rule_id: string;
+    /** The replacement rule, as created. */
+    term: PsiTermDto$1;
+    /** What withdrawing the previous rule removed. */
+    withdrawal: RuleWithdrawalReport$1;
+}
 /** Oversight verification result for the report. */
 interface ReportVerification {
     /**
@@ -24780,6 +24803,34 @@ interface RuleBaseCertificateDto {
     /** The termination guarantee (or why it could not be established). */
     termination: TerminationDto;
 }
+/**
+ * How an edit changed the rule base's termination and order-independence
+ * guarantees.
+ *
+ * An edit can turn a certified-terminating rule base into a non-terminating
+ * one, or introduce a functional conflict. `GET /api/v1/analysis/rule-base/certify`
+ * computes the certificate live, so there is no stale cache to invalidate —
+ * but a caller who never asks would discover the change when the next chain
+ * run diverges. The write path therefore certifies before and after and
+ * reports the delta.
+ */
+interface RuleCertificationDeltaDto {
+    /** Whether it is order-independent after. */
+    order_independent_after: boolean;
+    /** Whether it was order-independent before the edit. */
+    order_independent_before: boolean;
+    /**
+     * `true` when the edit weakened either guarantee. The edit is still
+     * applied — refusing it would make a rule base unfixable once a previous
+     * edit had broken it — but a client that ignores this field is flying
+     * blind into a diverging chain run.
+     */
+    regressed: boolean;
+    /** Whether the rule base terminated before the edit. */
+    terminated_before: boolean;
+    /** Whether it terminates after. */
+    terminates_after: boolean;
+}
 /** A rule clause (OSF clause) */
 interface RuleClauseDto$1 {
     /** Constraints on variables in this clause */
@@ -24800,6 +24851,32 @@ type RuleConstraintDto$1 = {
     var2: string;
     type: "equal";
 };
+/**
+ * What `DELETE /api/v1/inference/rules/{id}` and
+ * `PUT /api/v1/inference/rules/{id}` do about the conclusions the withdrawn
+ * rule derived.
+ *
+ * A rule is not a row. Deleting one that silently keeps its derivations
+ * leaves the knowledge base asserting conclusions whose only justification is
+ * gone; deleting one that silently drops them destroys conclusions the caller
+ * may not have known were at stake. Neither is a default anybody can audit,
+ * so the disposition is named in the query — the same cut
+ * `DELETE /api/v1/sorts/{id}?terms=…` applies to a sort's terms (#213).
+ *
+ * ## What it governs, and what it does not
+ *
+ * This decides the **materialized** tier only (`derived_facts`), because that
+ * tier cannot re-derive itself synchronously — a row the withdrawal leaves
+ * standing stays until the supervisor or a rebuild says otherwise.
+ *
+ * The **in-memory** tier is exact either way and needs no disposition: the
+ * withdrawal walks the truth-maintenance cone from each deleted term and then
+ * re-derives through the same cached `CHAIN;` plan the OSFQL service runs, so
+ * every conclusion the surviving rules still prove comes back and every one
+ * they do not is gone. The report's `consequences_invalidated` says how many
+ * fell before the re-derivation.
+ */
+type RuleDerivationsDisposition$1 = "refuse" | "retract";
 /** A draft inference rule. */
 interface RuleDraftDto$1 {
     /** Antecedent conditions (body). */
@@ -24885,6 +24962,63 @@ interface RuleUtilityDto$1 {
      */
     utility: number;
 }
+/**
+ * What withdrawing a rule removed, in every tier that held part of it.
+ *
+ * A rule is one head row, N body rows, a rule-index entry, a set of in-memory
+ * justifications, a set of `derived_facts` rows and their proof objects, and
+ * the derived terms themselves. A response reporting only "deleted" would
+ * name none of that, so each tier is counted separately.
+ */
+interface RuleWithdrawalReport$1 {
+    /**
+     * In-memory consequences invalidated by the truth-maintenance cone, before
+     * the surviving ones were re-derived.
+     * @min 0
+     */
+    consequences_invalidated: number;
+    /**
+     * Materialized derivations (`derived_facts` rows) whose last proof this
+     * rule was, so the row itself is gone.
+     * @min 0
+     */
+    derivations_removed: number;
+    /**
+     * Whether the derivation walk hit its visit cap and stopped early. A
+     * truncated retraction is not a complete one; re-issue the request.
+     */
+    derivations_truncated: boolean;
+    /**
+     * Materialized derivations that lost this rule's proofs but remain proved
+     * by another rule. These are correctly left standing.
+     * @min 0
+     */
+    derivations_weakened: number;
+    /**
+     * Incomplete dataflow queue entries cancelled because they named this rule.
+     * @min 0
+     */
+    queued_events_cancelled: number;
+    /**
+     * The rule that was withdrawn.
+     * @format uuid
+     */
+    rule_id: string;
+    /**
+     * Terms deleted with it: the head plus the body, guard, variable and
+     * operand terms the rule exclusively owned.
+     * @min 0
+     */
+    terms_deleted: number;
+    /**
+     * Terms of the rule's graph that were **kept** because something outside
+     * the rule still holds them — another rule's antecedent, or a fact the
+     * rule's body referenced. Deleting these would destroy data the rest of
+     * the knowledge base owns.
+     * @min 0
+     */
+    terms_retained_shared: number;
+}
 /** The payload an AG-UI client POSTs to start (or continue) a run. */
 interface RunAgentInput {
     /** Contextual key-value items. */
@@ -25972,6 +26106,46 @@ interface ShiftEffectResponse$1 {
      */
     std_error: number;
 }
+/**
+ * One sighting on the wire — one unknown surface form the lattice does not
+ * declare, with its recurrence evidence.
+ *
+ * Named `SightingDto`, not `ObservationDto`: the OpenAPI components namespace
+ * is FLAT, and `crates/api/src/dto/semiparametric.rs` already registers an
+ * `ObservationDto` — the `(x, a, y)` causal unit. Two live structs under one
+ * schema name meant the spec silently kept only one, and the survivor
+ * documented the wrong request body for `POST /api/v1/causal/ate` (#216). The
+ * name is the schema; a rename costs nothing on the wire because the JSON
+ * field names are the struct's, unchanged.
+ */
+interface SightingDto {
+    /**
+     * Sightings so far.
+     * @format int64
+     * @min 0
+     */
+    count: number;
+    /** Distinct source documents. */
+    documents: string[];
+    /**
+     * Unix seconds of the first sighting.
+     * @format int64
+     */
+    first_seen: number;
+    /**
+     * Unix seconds of the latest sighting.
+     * @format int64
+     */
+    last_seen: number;
+    /** The normalised identity observations aggregate under. */
+    normalized: string;
+    /** Who saw it (`ingestion`, `extraction_certificate`, `sentinel_near_miss`). */
+    producers: string[];
+    /** The proposed sort's id, once a generate pass minted one. */
+    proposed_sort_id?: string | null;
+    /** Representative surface form. */
+    surface: string;
+}
 /** A single similarity entry for bulk operations */
 interface SimilarityEntry {
     /**
@@ -34361,6 +34535,19 @@ declare class Inference<SecurityDataType = unknown> {
         /** Also delete referenced terms */
         delete_references?: boolean;
     }, params?: RequestParams) => Promise<HttpResponse<DeleteGoalResponse$1, void>>;
+    /**
+     * @description # The disposition is the caller's `?derivations=refuse` (the default) refuses while the rule still supports materialized conclusions and says how many; `?derivations=retract` withdraws them with it and reports the counts. A delete that silently drops derivations is as wrong as one that silently keeps them, so neither is the unnamed default. # Authorization Requires `X-Tenant-Id`. Runs the same delete guard as `DELETE /api/v1/terms/{id}` — a rule is a policy-relevant object, and withdrawing one changes what the engine will conclude. Honours `If-Match` against the conclusion's content ETag, and requires it under `OSFKB_REQUIRE_IF_MATCH=1`. Every request is captured by the audit middleware.
+     *
+     * @tags inference
+     * @name DeleteRule
+     * @summary Delete a rule.
+     * @request DELETE:/api/v1/inference/rules/{id}
+     * @secure
+     */
+    deleteRule: (id: string, query?: {
+        /** What to do about the conclusions this rule derived. */
+        derivations?: RuleDerivationsDisposition$1;
+    }, params?: RequestParams) => Promise<HttpResponse<RuleWithdrawalReport$1, void>>;
     /**
      * @description Never writes to the KB — returns validated drafts for human review.
      *
@@ -34443,15 +34630,15 @@ declare class Inference<SecurityDataType = unknown> {
      */
     getMetaSorts: (params?: RequestParams) => Promise<HttpResponse<MetaSortsResponse$1, any>>;
     /**
-     * @description # Authorization Requires X-Tenant-Id header.
+     * @description # Authorization Requires X-Tenant-Id header, and the path tenant must equal it. # The path segment Named `{id}` because `DELETE` and `PUT` on the same path address ONE RULE by term id (#231), and one segment cannot carry two names. Here it is the tenant — and a redundant one, since any value but the authenticated principal is refused.
      *
      * @tags inference
      * @name GetRules
      * @summary Get all rules (clauses with antecedents) for a tenant
-     * @request GET:/api/v1/inference/rules/{tenant_id}
+     * @request GET:/api/v1/inference/rules/{id}
      * @secure
      */
-    getRules: (tenantId: string, params?: RequestParams) => Promise<HttpResponse<GetRulesResponse$1, any>>;
+    getRules: (id: string, params?: RequestParams) => Promise<HttpResponse<GetRulesResponse$1, any>>;
     /**
      * @description # TRUE HOMOICONICITY Goals are Ψ-terms persisted to PostgreSQL. This endpoint returns all goals for the authenticated tenant with summary information. # Authorization Requires X-Tenant-Id header.
      *
@@ -34482,6 +34669,16 @@ declare class Inference<SecurityDataType = unknown> {
      * @secure
      */
     predictWithOrchestrator: (data: OrchestratorPredictRequest, params?: RequestParams) => Promise<HttpResponse<OrchestratorPredictResponse, void>>;
+    /**
+     * @description # An edit addresses ONE clause "Edit the rule for X" is ambiguous, because the authoring UI's "add clause" writes a *second* rule with the same conclusion, OR-unioned with the first. The path names a single rule term — one disjunct — so a client cannot silently edit the wrong one. # The old rule is withdrawn, not amended Everything `DELETE` does happens, always with the retract disposition: an edit that leaves the pre-edit clause's conclusions standing is exactly the defect this route exists to fix. The replacement is created through the same code `POST /api/v1/inference/rules` runs, so creation's guards — #227's guard canonicalisation, #219's range restriction, #217's certainty distinction — hold for an edit too, and a rejected replacement leaves the rule base untouched because the build runs BEFORE the clause is de-indexed. The response carries `previous_rule_id` alongside the new rule: a rule's id is its conclusion term id, so an edit changes it by construction. When the replacement is content-addressed to the same id (identical conclusion under `OSFKB_RULE_STABLE_IDS=1`), the two are equal and the edit was applied in place — the outgoing clause's now-unused antecedents are still collected and deleted. # Authorization Identical to `DELETE`: the delete guard on the outgoing rule, `If-Match` against its conclusion, and audit capture.
+     *
+     * @tags inference
+     * @name ReplaceRule
+     * @summary Replace a rule.
+     * @request PUT:/api/v1/inference/rules/{id}
+     * @secure
+     */
+    replaceRule: (id: string, data: AddRuleRequest$1, params?: RequestParams) => Promise<HttpResponse<ReplaceRuleResponse$1, void>>;
     /**
      * @description In OSF/LIFE terms, the orchestrator pushes the conclusion gate and each antecedent gate toward the dual-weighted satisfaction objective `1 − ( w_D · K_D + w_K · K_K )` (paper eq. 4). Each call performs exactly one epoch over the supplied batch — the response carries the per-epoch metrics for that single epoch (multi-epoch aggregation is the caller's responsibility). # Authorization Requires `X-Tenant-Id` header.
      *
@@ -35178,6 +35375,91 @@ interface GetRulesResponse {
     /** The rules (clauses with antecedents). */
     rules: RuleEntryDto[];
 }
+/** What a rule withdrawal does about the conclusions the rule derived. */
+type RuleDerivationsDisposition = 'refuse' | 'retract';
+/**
+ * What withdrawing a rule removed, in every tier that held part of it.
+ *
+ * @remarks
+ * A rule is not a row. It is one conclusion term, N antecedent pattern terms,
+ * a rule-index entry, a set of in-memory justifications, a set of materialized
+ * derivations with their proof objects, and the derived terms themselves. Each
+ * tier is counted separately, because a response reporting only "deleted" would
+ * name none of it.
+ */
+interface RuleWithdrawalReport {
+    /** The rule that was withdrawn (UUID). */
+    ruleId: string;
+    /**
+     * Terms deleted with it: the conclusion plus the antecedent, guard, variable
+     * and operand terms the rule exclusively owned.
+     */
+    termsDeleted: number;
+    /**
+     * Terms of the rule's graph that were KEPT because something outside the rule
+     * still holds them — another rule's antecedent, or a fact the body
+     * referenced. Deleting these would destroy data the rest of the knowledge
+     * base owns.
+     */
+    termsRetainedShared: number;
+    /** Materialized derivations whose last proof this rule was, so the row is gone. */
+    derivationsRemoved: number;
+    /**
+     * Materialized derivations that lost this rule's proofs but remain proved by
+     * another rule. These are correctly left standing.
+     */
+    derivationsWeakened: number;
+    /**
+     * Whether the derivation walk hit its visit cap and stopped early. A
+     * truncated retraction is not a complete one; re-issue the request.
+     */
+    derivationsTruncated: boolean;
+    /**
+     * In-memory consequences invalidated by the truth-maintenance cone, before
+     * the surviving ones were re-derived.
+     */
+    consequencesInvalidated: number;
+    /** Incomplete dataflow queue entries cancelled because they named this rule. */
+    queuedEventsCancelled: number;
+}
+/** How an edit changed the rule base's termination and order-independence guarantees. */
+interface RuleCertificationDelta {
+    /** Whether the rule base terminated before the edit. */
+    terminatedBefore: boolean;
+    /** Whether it terminates after. */
+    terminatesAfter: boolean;
+    /** Whether it was order-independent before the edit. */
+    orderIndependentBefore: boolean;
+    /** Whether it is order-independent after. */
+    orderIndependentAfter: boolean;
+    /**
+     * `true` when the edit weakened either guarantee. The edit is still applied —
+     * refusing it would make a rule base unfixable once a previous edit had
+     * broken it — but a client that ignores this is flying blind into a diverging
+     * chain run.
+     */
+    regressed: boolean;
+}
+/** Result of replacing a rule. */
+interface ReplaceRuleResponse {
+    /**
+     * The id the rule had before the edit.
+     *
+     * @remarks
+     * A rule's id IS its conclusion term id, so an edit changes it by
+     * construction. Durable references to the old id are retracted rather than
+     * migrated: a conclusion proved by the pre-edit clause is not proved by the
+     * post-edit one, which is the point of the edit. A client holding the old id
+     * must adopt the new one.
+     */
+    previousRuleId: string;
+    /** The replacement rule, as created. */
+    term: PsiTermDto;
+    /** What withdrawing the previous rule removed. */
+    withdrawal: RuleWithdrawalReport;
+    /** How the edit moved the rule base's guarantees. */
+    certification: RuleCertificationDelta;
+}
 /**
  * Response listing the meta-sorts (built-in system sorts) for inference.
  *
@@ -35507,17 +35789,21 @@ type inference_NafProveRequest = NafProveRequest;
 type inference_NafProveResponse = NafProveResponse;
 type inference_ProofDto = ProofDto;
 type inference_ProvenanceTagDto = ProvenanceTagDto;
+type inference_ReplaceRuleResponse = ReplaceRuleResponse;
 type inference_RuleAggregatorDto = RuleAggregatorDto;
+type inference_RuleCertificationDelta = RuleCertificationDelta;
+type inference_RuleDerivationsDisposition = RuleDerivationsDisposition;
 type inference_RuleDraftClarificationQuestionDto = RuleDraftClarificationQuestionDto;
 type inference_RuleDraftDto = RuleDraftDto;
 type inference_RuleEntryDto = RuleEntryDto;
 type inference_RuleTermDraftDto = RuleTermDraftDto;
+type inference_RuleWithdrawalReport = RuleWithdrawalReport;
 type inference_SolutionDto = SolutionDto;
 type inference_TaggedDerivedFact = TaggedDerivedFact;
 type inference_TaggedForwardChainRequest = TaggedForwardChainRequest;
 type inference_TaggedForwardChainResponse = TaggedForwardChainResponse;
 declare namespace inference {
-  export type { inference_AddFactRequest as AddFactRequest, inference_AddFactResponse as AddFactResponse, inference_AddRuleRequest as AddRuleRequest, inference_AddRuleResponse as AddRuleResponse, inference_AllenRelation as AllenRelation, inference_BackwardChainRequest as BackwardChainRequest, inference_BackwardChainResponse as BackwardChainResponse, inference_BayesianEffectDto as BayesianEffectDto, inference_BayesianPredictRequest as BayesianPredictRequest, inference_BayesianPredictResponse as BayesianPredictResponse, inference_BindingDto as BindingDto, inference_BulkAddFactsRequest as BulkAddFactsRequest, inference_BulkAddFactsResponse as BulkAddFactsResponse, inference_BulkAddRulesRequest as BulkAddRulesRequest, inference_BulkAddRulesResponse as BulkAddRulesResponse, inference_BulkFuzzyProveRequest as BulkFuzzyProveRequest, inference_BulkFuzzyProveResponse as BulkFuzzyProveResponse, inference_ClearFactsResponse as ClearFactsResponse, inference_ConstraintInputDto as ConstraintInputDto, inference_CreateGoalRequest as CreateGoalRequest, inference_CreateGoalResponse as CreateGoalResponse, inference_DeleteGoalResponse as DeleteGoalResponse, inference_DraftRulesRequest as DraftRulesRequest, inference_DraftRulesResponse as DraftRulesResponse, inference_FactConfidenceEntry as FactConfidenceEntry, inference_ForwardChainRequest as ForwardChainRequest, inference_ForwardChainResponse as ForwardChainResponse, inference_FuzzyProveRequest as FuzzyProveRequest, inference_FuzzyProveResponse as FuzzyProveResponse, inference_GetFactsResponse as GetFactsResponse, inference_GetRulesResponse as GetRulesResponse, inference_GoalDto as GoalDto, inference_GoalSummaryDto as GoalSummaryDto, inference_GuardOp as GuardOp, inference_HomoiconicSubstitutionDto as HomoiconicSubstitutionDto, inference_ListGoalsResponse as ListGoalsResponse, inference_LiteralInputDto as LiteralInputDto, inference_MetaSortsResponse as MetaSortsResponse, inference_NafProveRequest as NafProveRequest, inference_NafProveResponse as NafProveResponse, inference_ProofDto as ProofDto, inference_ProvenanceTagDto as ProvenanceTagDto, inference_RuleAggregatorDto as RuleAggregatorDto, inference_RuleDraftClarificationQuestionDto as RuleDraftClarificationQuestionDto, inference_RuleDraftDto as RuleDraftDto, inference_RuleEntryDto as RuleEntryDto, inference_RuleTermDraftDto as RuleTermDraftDto, inference_SolutionDto as SolutionDto, inference_TaggedDerivedFact as TaggedDerivedFact, inference_TaggedForwardChainRequest as TaggedForwardChainRequest, inference_TaggedForwardChainResponse as TaggedForwardChainResponse };
+  export type { inference_AddFactRequest as AddFactRequest, inference_AddFactResponse as AddFactResponse, inference_AddRuleRequest as AddRuleRequest, inference_AddRuleResponse as AddRuleResponse, inference_AllenRelation as AllenRelation, inference_BackwardChainRequest as BackwardChainRequest, inference_BackwardChainResponse as BackwardChainResponse, inference_BayesianEffectDto as BayesianEffectDto, inference_BayesianPredictRequest as BayesianPredictRequest, inference_BayesianPredictResponse as BayesianPredictResponse, inference_BindingDto as BindingDto, inference_BulkAddFactsRequest as BulkAddFactsRequest, inference_BulkAddFactsResponse as BulkAddFactsResponse, inference_BulkAddRulesRequest as BulkAddRulesRequest, inference_BulkAddRulesResponse as BulkAddRulesResponse, inference_BulkFuzzyProveRequest as BulkFuzzyProveRequest, inference_BulkFuzzyProveResponse as BulkFuzzyProveResponse, inference_ClearFactsResponse as ClearFactsResponse, inference_ConstraintInputDto as ConstraintInputDto, inference_CreateGoalRequest as CreateGoalRequest, inference_CreateGoalResponse as CreateGoalResponse, inference_DeleteGoalResponse as DeleteGoalResponse, inference_DraftRulesRequest as DraftRulesRequest, inference_DraftRulesResponse as DraftRulesResponse, inference_FactConfidenceEntry as FactConfidenceEntry, inference_ForwardChainRequest as ForwardChainRequest, inference_ForwardChainResponse as ForwardChainResponse, inference_FuzzyProveRequest as FuzzyProveRequest, inference_FuzzyProveResponse as FuzzyProveResponse, inference_GetFactsResponse as GetFactsResponse, inference_GetRulesResponse as GetRulesResponse, inference_GoalDto as GoalDto, inference_GoalSummaryDto as GoalSummaryDto, inference_GuardOp as GuardOp, inference_HomoiconicSubstitutionDto as HomoiconicSubstitutionDto, inference_ListGoalsResponse as ListGoalsResponse, inference_LiteralInputDto as LiteralInputDto, inference_MetaSortsResponse as MetaSortsResponse, inference_NafProveRequest as NafProveRequest, inference_NafProveResponse as NafProveResponse, inference_ProofDto as ProofDto, inference_ProvenanceTagDto as ProvenanceTagDto, inference_ReplaceRuleResponse as ReplaceRuleResponse, inference_RuleAggregatorDto as RuleAggregatorDto, inference_RuleCertificationDelta as RuleCertificationDelta, inference_RuleDerivationsDisposition as RuleDerivationsDisposition, inference_RuleDraftClarificationQuestionDto as RuleDraftClarificationQuestionDto, inference_RuleDraftDto as RuleDraftDto, inference_RuleEntryDto as RuleEntryDto, inference_RuleTermDraftDto as RuleTermDraftDto, inference_RuleWithdrawalReport as RuleWithdrawalReport, inference_SolutionDto as SolutionDto, inference_TaggedDerivedFact as TaggedDerivedFact, inference_TaggedForwardChainRequest as TaggedForwardChainRequest, inference_TaggedForwardChainResponse as TaggedForwardChainResponse };
 }
 
 /**
@@ -35630,6 +35916,78 @@ declare class InferenceClient {
      * ```
      */
     getRules(): Promise<GetRulesResponse>;
+    /**
+     * Withdraw one rule from the knowledge base.
+     *
+     * @param ruleId - Term id of the rule (its conclusion), as returned by
+     *   {@link InferenceClient.addRule} or {@link InferenceClient.getRules}.
+     * @param options - `derivations` decides what happens to the conclusions the
+     *   rule derived. Defaults to `'refuse'`.
+     * @returns What the withdrawal removed, tier by tier.
+     * @throws {ApiError} 400 if the id names a fact rather than a rule, or if the
+     *   rule still supports derivations under the default `'refuse'`; 403 for a
+     *   system, plugin-owned or bootstrap rule; 404 if no such rule exists.
+     *
+     * @remarks
+     * A rule is not a row. Withdrawing one deletes its conclusion AND the
+     * antecedent pattern, guard and variable terms it exclusively owns — a
+     * conclusion-only delete would leave those patterns readable as ordinary
+     * facts — while keeping every term the rest of the knowledge base still
+     * holds.
+     *
+     * `'refuse'` (the default) refuses while the rule still proves materialized
+     * conclusions and says how many; `'retract'` withdraws them with it. A delete
+     * that silently drops derivations is as wrong as one that silently keeps
+     * them, so neither is the unnamed default.
+     *
+     * @example
+     * ```typescript
+     * const report = await client.inference.deleteRule(ruleId, { derivations: 'retract' });
+     * console.log(report.termsDeleted, report.derivationsRemoved);
+     * ```
+     */
+    deleteRule(ruleId: string, options?: {
+        derivations?: RuleDerivationsDisposition;
+    }): Promise<RuleWithdrawalReport>;
+    /**
+     * Replace one rule with a new one.
+     *
+     * @param ruleId - Term id of the rule (its conclusion) to replace.
+     * @param request - The replacement rule, in the same shape
+     *   {@link InferenceClient.addRule} takes.
+     * @returns The replacement, the id it replaced, what the withdrawal removed,
+     *   and how the rule base's guarantees moved.
+     * @throws {ApiError} 422 if the replacement is rejected by the authoring
+     *   guards — in which case the original rule is left live; 400/403/404 as for
+     *   {@link InferenceClient.deleteRule}.
+     *
+     * @remarks
+     * A rule's id IS its conclusion term id, so an edit changes it by
+     * construction. The response carries `previousRuleId` alongside the new
+     * rule; a client holding the old id must adopt the new one.
+     *
+     * The path names ONE rule term — one disjunct. Two rules with the same
+     * conclusion are OR-unioned, so "edit the rule for X" is ambiguous and this
+     * addresses a single clause.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.inference.replaceRule(ruleId, {
+     *   term: psi('retiree', { name: Var('N') }),
+     *   antecedents: [psi('person', { name: Var('N') })],
+     * });
+     * console.log(result.previousRuleId, '->', result.term.termId);
+     * if (result.certification.regressed) {
+     *   console.warn('the edit weakened the rule base guarantees');
+     * }
+     * ```
+     */
+    replaceRule(ruleId: string, request: {
+        term: TermInputArg;
+        antecedents?: TermInputArg[];
+        certainty?: number;
+        aggregator?: RuleAggregatorDto | null;
+    }): Promise<ReplaceRuleResponse>;
     /**
      * Query for matching data by searching rules and facts backwards from a goal pattern.
      *