@kortexya/reasoninglayer 1.4.0 → 1.6.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.4.0";
+declare const SDK_VERSION = "1.6.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -281,6 +281,44 @@ declare class HttpClient<SecurityDataType = unknown> {
     request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<HttpResponse<T, E>>;
 }
 
+/** A validation rule over a single parameter (externally tagged). */
+type ActionParamRuleDto = {
+    /** String parameter, when present, must be non-empty. */
+    non_empty_string: {
+        param: string;
+    };
+} | {
+    /** Integer parameter, when present, in `[min, max]`. */
+    int_range: {
+        /** @format int64 */
+        max: number;
+        /** @format int64 */
+        min: number;
+        param: string;
+    };
+} | {
+    /** Real parameter, when present, in `[min, max]`. */
+    real_range: {
+        /** @format double */
+        max: number;
+        /** @format double */
+        min: number;
+        param: string;
+    };
+} | {
+    /** String parameter, when present, must be one of `allowed`. */
+    one_of: {
+        allowed: string[];
+        param: string;
+    };
+};
+/** One action parameter projected from an [`ActionInputSpec`]. */
+interface ActionParameterDto {
+    /** Parameter (input feature) name. */
+    name: string;
+    /** Whether the input is required. */
+    required: boolean;
+}
 /** Reason why an action requires review */
 type ActionReviewReasonDto$1 = "requires_approval" | "high_risk" | "external_side_effect" | "low_confidence" | "first_use" | {
     /** Custom reason */
@@ -328,6 +366,49 @@ interface ActionReviewSummaryDto$1 {
      */
     total_pending: number;
 }
+/** A declarative side-effect fired after the action applies. */
+interface ActionSideEffectDto {
+    /** Notification body. */
+    body: string;
+    /** Delivery channel: `webhook`, `email`, `in_app`, or `browser_push`. */
+    channel: string;
+    /** Recipient/target (webhook URL or recipient address). */
+    target: string;
+    /** Notification title. */
+    title: string;
+}
+/** A typed, validated, RBAC-bound action schema. */
+interface ActionTypeDefDto {
+    /** Action type name (the action sort). */
+    name: string;
+    /** Typed parameters. */
+    params?: ParamSpecDto[];
+    /** Roles required to apply this action (empty ⇒ unrestricted). */
+    required_roles?: string[];
+    /** Validation rules over parameters. */
+    rules?: ActionParamRuleDto[];
+    /** Side-effects to dispatch once the action applies. */
+    side_effects?: ActionSideEffectDto[];
+}
+/** One projected action type. */
+interface ActionTypeDto {
+    /** Action sort name (Palantir action-type apiName). */
+    apiName: string;
+    /** Human-facing name (the action sort name). */
+    displayName: string;
+    /** Parameters — required inputs first, then optional. */
+    parameters: ActionParameterDto[];
+}
+/** Response for `GET /api/v1/ontology/action-types`. */
+interface ActionTypeListResponse$1 {
+    /** The projected action types. */
+    actionTypes: ActionTypeDto[];
+    /**
+     * Number of action types returned.
+     * @min 0
+     */
+    count: number;
+}
 /** Activation level DTO. */
 interface ActivationDto$1 {
     /**
@@ -774,6 +855,55 @@ interface AgentSubVerdictDto$1 {
     /** Per-agent verdict: "safe", "unsafe", "partial", or "residuated" */
     verdict: string;
 }
+/** Request to align a domain ontology to an upper ontology. */
+interface AlignOntologyRequest$1 {
+    /** Domain ontology to align, as OWL/RDF-XML. */
+    domain_owl: string;
+    /** Upper ontologies to align against. Defaults to `["BFO"]` when empty. */
+    targets?: string[];
+}
+/** Response from an ontology-alignment run. */
+interface AlignOntologyResponse$1 {
+    /** Surfaced ⊥-conflicts among proposed candidates. */
+    conflicts: AlignmentConflictDto$1[];
+    /**
+     * Number of domain sorts considered.
+     * @min 0
+     */
+    domain_sorts: number;
+    /** The MAPPING artifact as Turtle (`skos:*` + `kortexya:confidence`). */
+    mapping_ttl: string;
+    /** Confirmed SKOS correspondences. */
+    matches: AlignmentMatchDto$1[];
+    /**
+     * Number of upper-ontology target sorts indexed.
+     * @min 0
+     */
+    target_sorts: number;
+}
+/**
+ * Two upper-ontology candidates a domain class cannot map to simultaneously
+ * (their lattice meet is ⊥ — e.g. disjoint BFO branches).
+ */
+interface AlignmentConflictDto$1 {
+    /** Domain sort name whose candidates conflict. */
+    domain_sort: string;
+    /** The kept (higher-scored) candidate CURIE. */
+    target_a: string;
+    /** The rejected, incompatible candidate CURIE. */
+    target_b: string;
+}
+/** A confirmed SKOS correspondence from a domain class to an upper-ontology class. */
+interface AlignmentMatchDto$1 {
+    /** Domain sort name. */
+    domain_sort: string;
+    /** SKOS relation: `exactMatch` / `broadMatch` / `narrowMatch` / `closeMatch`. */
+    match_type: string;
+    /** Upper-ontology class CURIE (e.g. the BFO IRI's CURIE form). */
+    target_curie: string;
+    /** Upper-ontology class label. */
+    target_label: string;
+}
 /** Statistics for source text alignment quality */
 interface AlignmentStatsDto {
     /**
@@ -866,6 +996,43 @@ interface AppendResiduationsResponse$1 {
     /** @min 0 */
     total_residuations: number;
 }
+/** Request body for `POST /api/v1/actions/apply`. */
+interface ApplyActionRequest$1 {
+    /** The action schema to apply. */
+    action: ActionTypeDefDto;
+    /** Roles held by the caller (checked against `action.required_roles`). */
+    caller_roles?: string[];
+    /** Multi-term edits to commit atomically when the action is `Ready`. */
+    edits?: TermEditDto[];
+    /** Bound input features (`feature → JSON value`). */
+    inputs?: Record<string, any>;
+}
+/** Outcome of applying an action (the `outcome` field discriminates). */
+type ApplyActionResponse$1 = {
+    outcome: "applied";
+    /**
+     * Number of side-effects delivered successfully.
+     * @min 0
+     */
+    side_effects_dispatched: number;
+    /**
+     * Number of side-effects whose delivery failed (apply still succeeded).
+     * @min 0
+     */
+    side_effects_failed: number;
+} | {
+    /** Names of the unbound required parameters. */
+    missing: string[];
+    outcome: "suspended";
+} | {
+    outcome: "rejected";
+    /** Human-readable reason. */
+    reason: string;
+} | {
+    outcome: "rolled_back";
+    /** Human-readable cause. */
+    reason: string;
+};
 /** Request to apply arguments to a curried function */
 interface ApplyCurriedRequest$1 {
     arguments: PositionalArgumentDto$1[];
@@ -1155,6 +1322,14 @@ interface AssignmentDto {
  * Every cell in the input grid is classified as exactly one of these.
  */
 type AssignmentStatusDto = "confirmed_true" | "confirmed_false" | "free";
+/** Request body for `POST /api/v1/feasibility/sessions/{session_id}/assumptions`. */
+interface AssumptionRequest$1 {
+    /**
+     * The flat decision-variable index to assume `true`.
+     * @min 0
+     */
+    var: number;
+}
 /** Attention target DTO. */
 type AttentionTargetDto$1 = {
     /** @format uuid */
@@ -1649,6 +1824,28 @@ interface BeliefDto$1 {
 }
 /** Binary operator for expressions */
 type BinaryOperatorDto$1 = "Add" | "Subtract" | "Multiply" | "Divide";
+/** Request to bind a sort to a SQL table. */
+interface BindSortRequest$1 {
+    /** Column mappings: feature name to column spec. */
+    columns: ColumnMappingDto$1[];
+    /** Primary key column names. */
+    key_columns?: string[];
+    /** Sort name to bind. */
+    sort_name: string;
+    /** External source identifier. */
+    source_id: string;
+    /** SQL table name. */
+    table_name: string;
+}
+/** Response from binding a sort to a SQL table. */
+interface BindSortResponse$1 {
+    /** Whether the binding was successful. */
+    bound: boolean;
+    /** Sort name that was bound. */
+    sort_name: string;
+    /** SQL table the sort is bound to. */
+    table_name: string;
+}
 /** Request to bind a term in the session */
 interface BindTermRequest$1 {
     features?: FeatureBindingDto$1[];
@@ -1722,6 +1919,22 @@ interface BindingDto$1 {
      */
     variable_term_id: string;
 }
+/** Summary of a single sort-table binding. */
+interface BindingSummaryDto$1 {
+    /**
+     * Number of bound features/columns.
+     * @min 0
+     */
+    feature_count: number;
+    /** Primary key column names. */
+    key_columns: string[];
+    /** Sort ID (UUID string). */
+    sort_id: string;
+    /** External source identifier. */
+    source_id: string;
+    /** SQL table name. */
+    table_name: string;
+}
 /** Response with current bindings */
 interface BindingsResponse$1 {
     bindings: TermBindingDto$1[];
@@ -1748,6 +1961,64 @@ type BitwiseResponse = {
     reason: string;
     status: "fail";
 };
+/**
+ * A boolean-valued expression for the [`TypedConstraintDto::Arithmetic`] escape
+ * hatch (mirrors the domain `BoolExpr`). Tagged by `type`. `not`/`implies`/
+ * `iff`/`xor` are convenience nodes; an empty `and` is true, an empty `or` is
+ * false.
+ */
+type BoolExprDto = {
+    type: "lit";
+    /** The polarity. */
+    value: boolean;
+    /**
+     * The flat decision-variable index.
+     * @min 0
+     */
+    var: number;
+} | {
+    type: "const";
+    /** The truth value. */
+    value: boolean;
+} | {
+    /** The negated expression. */
+    expr: BoolExprDto;
+    type: "not";
+} | {
+    /** The conjuncts. */
+    exprs: BoolExprDto[];
+    type: "and";
+} | {
+    /** The disjuncts. */
+    exprs: BoolExprDto[];
+    type: "or";
+} | {
+    /** Antecedent. */
+    left: BoolExprDto;
+    /** Consequent. */
+    right: BoolExprDto;
+    type: "implies";
+} | {
+    /** Left operand. */
+    left: BoolExprDto;
+    /** Right operand. */
+    right: BoolExprDto;
+    type: "iff";
+} | {
+    /** Left operand. */
+    left: BoolExprDto;
+    /** Right operand. */
+    right: BoolExprDto;
+    type: "xor";
+} | {
+    /** Left-hand linear expression. */
+    left: LinExprDto;
+    /** The relational operator. */
+    op: RelOpDto$1;
+    /** Right-hand linear expression. */
+    right: LinExprDto;
+    type: "compare";
+};
 /**
  * API representation of an OSF Bound Constraint
  *
@@ -2506,6 +2777,70 @@ interface ClarificationQuestionDto$1 {
     question: string;
     type: string;
 }
+/** Per-cell trichotomy, partitioned by class (flat cell indices). */
+interface ClassificationDto {
+    /** Cells in no valid completion — gray these out. */
+    confirmed_false: number[];
+    /** Cells in every valid completion — forced/highlighted. */
+    confirmed_true: number[];
+    /** Cells that are a free choice. */
+    sometimes: number[];
+}
+interface ClassificationLevelDto$1 {
+    /**
+     * @format int32
+     * @min 0
+     */
+    level: number;
+    name: string;
+}
+/**
+ * Request body for `POST /api/v1/solver/classify`.  Same fields as
+ * `SolveProblemRequest` plus an optional list of variable names whose
+ * classification is requested; omitting it classifies every binary
+ * variable.
+ */
+interface ClassifyProblemRequest$1 {
+    constraints?: LinearConstraint$2[];
+    /** @format double */
+    gap_tolerance?: number | null;
+    /**
+     * Backend-selection hint.  `Auto` (default) routes CP-SAT for fully
+     * discrete problems and HiGHS for any continuous variable.
+     */
+    hint?: SolverHint$1;
+    objective?: null | Objective$1;
+    /**
+     * @format int64
+     * @min 0
+     */
+    time_limit_ms?: number | null;
+    variables: VariableSpec$1[];
+    /**
+     * Variables to classify.  Omit (or send empty) to classify every
+     * binary variable.
+     */
+    variables_of_interest?: any[] | null;
+}
+/** Response body for `POST /api/v1/solver/classify`. */
+interface ClassifyProblemResponse$1 {
+    /**
+     * Variable-name → baseline solve value.  Useful for displaying a
+     * concrete witness alongside the classification.
+     */
+    baseline_values: Record<string, number>;
+    /**
+     * Variable-name → classification.  Empty when baseline is
+     * infeasible.
+     */
+    classifications: Record<string, VariableClassification$1>;
+    message?: string | null;
+    /** @format double */
+    solve_time_ms: number;
+    solver: string;
+    /** Status reported by the solver. */
+    status: SolutionStatus$1;
+}
 /** Request for safety classification (Phase 5). */
 interface ClassifySafetyRequest$1 {
     /** Text to classify for safety violations. */
@@ -2674,6 +3009,21 @@ interface CollectionResponse {
     /** Collection DTO */
     collection: CollectionDto$1;
 }
+/** Mapping between an OSF feature and a SQL column. */
+interface ColumnMappingDto$1 {
+    /** SQL column name. */
+    column: string;
+    /** OSF feature name. */
+    feature: string;
+    /** Whether the column is nullable. */
+    nullable?: boolean;
+    /**
+     * SQL type (e.g., "VARCHAR(255)", "INTEGER"). Omit or leave empty to have
+     * the server introspect the real type from the registered source's live
+     * schema (falls back to TEXT if the source isn't connected).
+     */
+    sql_type?: string;
+}
 /**
  * Request body for `POST /api/v1/flow-networks/{id}/commit` —
  * structural mutations applied in a single atomic step.
@@ -3041,6 +3391,40 @@ interface ConfirmResponseDto {
 }
 /** How to resolve feature conflicts when merging */
 type ConflictResolution$1 = "keep_existing" | "use_new" | "merge";
+/**
+ * A concrete order-dependence counterexample: two rules that derive conflicting
+ * values for a feature declared functional.
+ */
+interface ConfluenceConflictDto {
+    /** The two conflicting values the rules derive for the same entity. */
+    conflicting_values: string[];
+    /** The functional feature the two rules disagree on. */
+    feature: string;
+    /** The kind of conflict (currently always `"functional-dependency-violation"`). */
+    kind: string;
+}
+/** Confluence (order-independence) half of the certificate. */
+interface ConfluenceDto {
+    /** The concrete counterexample, when the rule base is not order-independent. */
+    conflict?: null | ConfluenceConflictDto;
+    /**
+     * `true` iff forward reasoning produces the same result regardless of the
+     * order rules fire in.
+     */
+    order_independent: boolean;
+    /**
+     * Why: `"monotone-least-fixpoint"`, `"congruence-closure"`, `"monotone-chase"`,
+     * `"vacuous"`, `"branching"` (disjunctive rules explore multiple models), or
+     * `"functional-conflict"` (a counterexample was found).
+     */
+    reason: string;
+    /**
+     * Number of rule interactions found (places one rule's output can trigger
+     * another). All are order-safe when `order_independent` is `true`.
+     * @min 0
+     */
+    rule_interactions: number;
+}
 /** A single constraint check in the verification result. */
 interface ConstraintCheckDto$1 {
     /** Description of the constraint. */
@@ -3211,6 +3595,8 @@ type ConstraintInputDto$1 = {
     relation: string;
     type: "Allen";
 };
+/** Comparison sense of a linear constraint. */
+type ConstraintSense$1 = "leq" | "geq" | "eq";
 /**
  * Session status information
  *
@@ -3771,6 +4157,66 @@ interface CreateStoreTermRequest$1 {
     features?: Record<string, object>;
     sort_id: string;
 }
+/**
+ * Request to explicitly provision a new tenant.
+ *
+ * Until now tenants came into existence only implicitly, on first write. This
+ * makes provisioning explicit: it materialises the tenant's inference state and
+ * per-tenant sort hierarchy up front, and optionally seeds initial sorts. The
+ * seeded sorts are real lattice insertions (not placeholders) — full
+ * Marketplace-pack seeding is layered on later via the pack installer.
+ */
+interface CreateTenantRequest$1 {
+    /**
+     * Optional owner user UUID for the tenant's initial state. Generated when omitted.
+     * @format uuid
+     */
+    owner_user_id?: string | null;
+    /** Optional sort names to seed into the new tenant's hierarchy as top-level sorts. */
+    seed_sorts?: string[];
+    /**
+     * Optional explicit tenant UUID. A fresh UUID is generated when omitted.
+     * @format uuid
+     */
+    tenant_id?: string | null;
+}
+/** Response for the create-tenant operation. */
+interface CreateTenantResponse$1 {
+    /** `true` if the tenant was newly created; `false` if it already existed (idempotent). */
+    created: boolean;
+    /**
+     * Number of seed sorts successfully inserted into the tenant hierarchy.
+     * @min 0
+     */
+    seeded_sorts: number;
+    /** The provisioned tenant UUID (echoes the request or the generated value). */
+    tenant_id: string;
+}
+/** Request to create a term within a specific collection */
+interface CreateTermInCollectionRequest$1 {
+    /**
+     * Collection ID to add the term to
+     * @format uuid
+     */
+    collection_id: string;
+    /** Term features */
+    features: Record<string, ValueDto$1>;
+    /**
+     * Namespace ID
+     * @format uuid
+     */
+    namespace_id: string;
+    /**
+     * Sort ID for the term
+     * @format uuid
+     */
+    sort_id: string;
+    /**
+     * Tenant ID
+     * @format uuid
+     */
+    tenant_id: string;
+}
 /**
  * Request to create a term
  *
@@ -5535,6 +5981,11 @@ interface EmbeddingVerificationResponse$1 {
     /** Volume-specificity verification result. */
     specificity?: null | SpecificityDto$1;
 }
+/** Response to ending a session. */
+interface EndSchedulingResponse$1 {
+    /** Whether a live session was removed. */
+    ended: boolean;
+}
 /** Enriched health response with component statuses and build info */
 interface EnrichedHealthResponse$1 {
     /** Build info DTO */
@@ -6218,6 +6669,19 @@ interface ExternalActionSummaryDto$1 {
     /** Webhook URL */
     webhook_url: string;
 }
+/**
+ * SKOS external-ontology alignment surfaced on a [`SortDto`] — e.g. a BFO/CCO
+ * correspondence attached by the upper-ontology aligner. This makes each
+ * alignment a live, queryable property of the sort, not a separate export.
+ */
+interface ExternalMatchDto$1 {
+    /** SKOS mapping relation: `exactMatch` | `closeMatch` | `broadMatch` | `narrowMatch`. */
+    match_type: string;
+    /** CURIE of the aligned external concept (e.g. `obo:BFO_0000023`). */
+    ontology_id: string;
+    /** How the match was discovered: `grounding` | `manual` | `import` | `inferred`. */
+    source: string;
+}
 /**
  * Request to extract named entities from text using the tenant's sort hierarchy as labels.
  *
@@ -6583,10 +7047,16 @@ type FeatureConstraintDto = {
 interface FeatureDescriptorDto$1 {
     /** Custom OWL annotations for this feature (e.g., isIdentifier, unit, enumValues) */
     annotations?: Record<string, string>;
-    /** Optional constraint on the feature value */
+    /**
+     * Optional constraint on the feature value. Defaults to `None`
+     * when absent so callers needn't send an explicit null.
+     */
     constraint?: null | ConstraintDto$1;
     /**
-     * Expected sort for the feature value (for nested PSI-terms)
+     * Expected sort for the feature value (for nested PSI-terms).
+     * Optional — omit for a primitive/un-typed feature. Defaults to
+     * `None` when absent from the request body so a minimal
+     * `{"name", "required"}` descriptor deserializes.
      * @format uuid
      */
     expected_sort?: string | null;
@@ -6615,6 +7085,9 @@ interface FeatureDescriptorDto$1 {
 type FeatureInputValueDto$1 = {
     /** @format uuid */
     term_id: string;
+} | {
+    /** @format uuid */
+    sort_ref: string;
 } | {
     name: string;
 } | {
@@ -7108,6 +7581,15 @@ interface ForwardChainResponse$1 {
      */
     total_facts: number;
 }
+/** One migration item a human should review. */
+interface FoundryReviewItemDto$1 {
+    /** What kind of item (`property_type`, `action_type`). */
+    kind: string;
+    /** The item's apiName. */
+    name: string;
+    /** Why it needs review. */
+    reason: string;
+}
 /** Function body - what to compute */
 type FunctionBodyDto$1 = {
     type: "Value";
@@ -7129,6 +7611,57 @@ interface FunctionClauseDto$1 {
     guard?: null | GuardDto;
     parameters: PatternDto$1[];
 }
+/**
+ * Typed signature summary for a single registered function.
+ *
+ * This is the OSF/LIFE realisation of a Palantir "Function Type" entry: a
+ * function is a Ψ-term in the function sub-lattice, and its signature is the
+ * arity plus the number of pattern-matched clauses (LIFE-style bidirectional
+ * evaluation). Returned by the `GET /api/v1/functions` discovery endpoint so a
+ * client (or the Studio Functions page) can enumerate callable functions
+ * without evaluating them.
+ */
+interface FunctionSummaryDto$1 {
+    /**
+     * Number of named arguments the function accepts.
+     * @min 0
+     */
+    arity: number;
+    /**
+     * Number of pattern-matched clauses (tried in order during evaluation).
+     * @min 0
+     */
+    clauses_count: number;
+    /** Function name (the key used by `POST /functions/evaluate`). */
+    name: string;
+}
+/** One projected function type. */
+interface FunctionTypeDto {
+    /** Function name (Palantir function-type apiName). */
+    apiName: string;
+    /**
+     * Number of named-feature parameters (the function's arity).
+     * @min 0
+     */
+    arity: number;
+    /**
+     * Number of defining clauses (homoiconic rules) backing the function.
+     * @min 0
+     */
+    clausesCount: number;
+    /** Human-facing name (the function name). */
+    displayName: string;
+}
+/** Response for `GET /api/v1/ontology/function-types`. */
+interface FunctionTypeListResponse$1 {
+    /**
+     * Number of function types returned.
+     * @min 0
+     */
+    count: number;
+    /** The projected function types, ordered by apiName. */
+    functionTypes: FunctionTypeDto[];
+}
 /** Value type for literals */
 type FunctionValueDto$1 = {
     type: "Integer";
@@ -7595,6 +8128,16 @@ interface GFlowNetTrainResponse$1 {
     /** Whether training was triggered. */
     triggered: boolean;
 }
+interface GateRequest$1 {
+    clearance: string;
+    marking: string;
+}
+interface GateResponse$1 {
+    clearance: string;
+    decision: string;
+    dominates: boolean;
+    marking: string;
+}
 /**
  * GeneralConstraintDto
  * General constraint: Arithmetic, Basic {constraint_type, value}, Conjunction {constraints}, or Disjunction {constraints}
@@ -7848,6 +8391,27 @@ interface GenerationReportDto$1 {
      */
     validation_failures: number;
 }
+/**
+ * Request body for `POST /api/v1/feasibility/sessions`. The
+ * `choice_points` define the flat decision-variable layout (a binary choice ⇒
+ * one boolean; an `n`-way choice ⇒ `n` one-hot vars + an implied exactly-one);
+ * `constraints` are posted over those variables.
+ */
+interface GenericModelRequest$1 {
+    /** The decisions to explore, in order. Each must have `alternative_count ≥ 2`. */
+    choice_points: ChoicePointDto$1[];
+    /** The typed constraints over the flat decision variables. */
+    constraints?: TypedConstraintDto[];
+    /**
+     * Optional linear objective to **maximize** (`Σ weight·var` over the true
+     * decision variables), as `(var, weight)` terms. Empty ⇒ pure-feasibility
+     * mode (the trichotomy over all feasible completions). Non-empty ⇒ optimize
+     * mode: the trichotomy is taken over the **maximum-weight** completions and
+     * the responses carry `total_score` (the optimum). A var absent from the
+     * list has weight `0`; duplicate vars sum.
+     */
+    objective?: LinTermDto[];
+}
 /** Request to get agent state. */
 interface GetAgentStateRequest$1 {
     /**
@@ -8056,6 +8620,16 @@ interface GetResiduationsResponse$1 {
     residuations: ResiduationDetailDto$1[];
     term_id: string;
 }
+/** Response listing all rules for a tenant. */
+interface GetRulesResponse$1 {
+    /**
+     * Total count.
+     * @min 0
+     */
+    count: number;
+    /** The rules. */
+    rules: RuleEntryDto$1[];
+}
 /** Response for GET /api/v1/scenarios/:id — retrieve a stored scenario. */
 interface GetScenarioResponse$1 {
     /** Agent TermId (if an agent was created). */
@@ -8508,6 +9082,28 @@ interface GroundTruthEntry$1 {
     term_id: string;
 }
 type GroundTruthStatus$1 = "Pending" | "Validated" | "Refuted" | "Unknown";
+/** Response from grounded NL schema generation. */
+interface GroundedSchemaResponse$1 {
+    /**
+     * Number of inference tools.
+     * @min 0
+     */
+    inference_tools: number;
+    /** Human-readable ontology summary. */
+    ontology_summary: string;
+    /**
+     * Number of query tools generated.
+     * @min 0
+     */
+    query_tools: number;
+    /** System prompt for LLM grounding. */
+    system_prompt: string;
+    /**
+     * Number of write tools generated.
+     * @min 0
+     */
+    write_tools: number;
+}
 /** Statistics for entity grounding (linking to external ontologies) */
 interface GroundingStatsDto$1 {
     /**
@@ -8827,6 +9423,43 @@ interface ImpliesResponse$1 {
     /** True if implication holds (antecedent fails OR consequent succeeds) */
     result: boolean;
 }
+/** Request to import a Foundry ontology export (Q1.8). */
+interface ImportFoundryRequest$1 {
+    /** The Foundry ontology export, as JSON. */
+    foundry_json: string;
+}
+/** Response from a Foundry import: what was created + a mapped/review-needed report. */
+interface ImportFoundryResponse$1 {
+    /**
+     * Interface types mapped to (super) sorts.
+     * @min 0
+     */
+    mapped_interface_types: number;
+    /**
+     * Link types mapped to referring features.
+     * @min 0
+     */
+    mapped_links: number;
+    /**
+     * Object types mapped to sorts.
+     * @min 0
+     */
+    mapped_object_types: number;
+    /**
+     * Properties mapped to features.
+     * @min 0
+     */
+    mapped_properties: number;
+    /**
+     * Number of relations discovered from link types.
+     * @min 0
+     */
+    relations_discovered: number;
+    /** Items imported with a caveat or skipped — need human review. */
+    review_needed: FoundryReviewItemDto$1[];
+    /** Names of sorts created (object + interface types). */
+    sorts_created: string[];
+}
 /** Request to import a module */
 interface ImportModuleRequest$1 {
     /** Optional alias for the import */
@@ -8843,6 +9476,23 @@ interface ImportModuleResponse$1 {
     importer_module: string;
     success: boolean;
 }
+/** Request to import an OWL/RDF ontology into the sort hierarchy. */
+interface ImportOwlRequest$1 {
+    /** OWL/RDF XML content to import. */
+    rdf_xml: string;
+}
+/** Response from an OWL ontology import. */
+interface ImportOwlResponse$1 {
+    /** Names of reified sorts created (many-to-many with attributes). */
+    reified_sorts_created: string[];
+    /**
+     * Number of relations discovered from OWL object properties.
+     * @min 0
+     */
+    relations_discovered: number;
+    /** Names of sorts created from OWL classes. */
+    sorts_created: string[];
+}
 /** A message in the inbox. */
 interface InboxMessageDto {
     /** Message content (arbitrary JSON) */
@@ -9059,6 +9709,16 @@ interface IngestRdfRequest$1 {
     content: string;
     /** Format of the RDF content */
     format: RdfFormatDto$1;
+    /**
+     * Whether to materialise OWL/RDFS class & property *declarations*
+     * (`:p a owl:DatatypeProperty`, `:C a owl:Class`) as queryable identity terms.
+     *
+     * Default `false` keeps declarations as schema (out of `?s ?p ?o`), the
+     * established behaviour for ordinary ingest. Set `true` only for SPARQL OWL/RDFS
+     * entailment workloads, where `?p a owl:DatatypeProperty` and `?c rdfs:subClassOf
+     * ?d` must match declarations.
+     */
+    keep_declarations?: boolean;
     /** Whether to also parse OWL ontology from the content */
     parse_ontology?: boolean;
     /** Whether to also parse SHACL shapes from the content */
@@ -9610,6 +10270,29 @@ interface IntentionDto$1 {
      */
     status?: string;
 }
+/** One projected interface type — a non-maximal sort. */
+interface InterfaceTypeDto {
+    /** Sort name (Palantir interface-type apiName). */
+    apiName: string;
+    /** Sort description, if any. */
+    description?: string | null;
+    /** Human-facing name (the sort name). */
+    displayName: string;
+    /** apiNames of supersorts that are themselves interfaces (extended interfaces). */
+    extendsInterfaceTypes: string[];
+    /** The appropriate scalar features that form the inherited contract. */
+    properties: PropertyDto[];
+}
+/** Response for `GET /api/v1/ontology/interface-types`. */
+interface InterfaceTypeListResponse$1 {
+    /**
+     * Number of interface types returned.
+     * @min 0
+     */
+    count: number;
+    /** The projected interface types. */
+    interfaceTypes: InterfaceTypeDto[];
+}
 interface InterventionObservationRequest$1 {
     /** Variables that changed after intervention */
     changed_variables: string[];
@@ -10352,6 +11035,73 @@ interface LeastSortsResponse {
     /** @format uuid */
     tenant_id: string;
 }
+/**
+ * An integer-valued linear expression `constant + Σ coeff·var` over boolean
+ * cells (each cell contributes its coefficient when set).
+ */
+interface LinExprDto {
+    /**
+     * The constant addend.
+     * @format int64
+     */
+    constant?: number;
+    /** The `coeff·var` terms. */
+    terms?: LinTermDto[];
+}
+/** One term `coeff · var` of a [`LinExprDto`]. */
+interface LinTermDto {
+    /**
+     * The integer coefficient.
+     * @format int64
+     */
+    coeff: number;
+    /**
+     * The flat decision-variable index.
+     * @min 0
+     */
+    var: number;
+}
+/**
+ * A linear constraint `Σ coef_i · x_i (sense) rhs`.  Variables not
+ * referenced in `coefficients` are treated as if their coefficient is
+ * zero.
+ */
+interface LinearConstraint$2 {
+    /** Variable-name → coefficient. */
+    coefficients: Record<string, number>;
+    /** Optional caller-supplied label, returned in error reports. */
+    name?: string | null;
+    /**
+     * Right-hand side.
+     * @format double
+     */
+    rhs: number;
+    /** Comparison sense. */
+    sense: ConstraintSense$1;
+}
+/** One projected link type — a referring feature from one sort to another. */
+interface LinkTypeDto {
+    /** Qualified apiName `"<sort>.<feature>"`. */
+    apiName: string;
+    /** Cardinality — `ONE`, because OSF features are functional. */
+    cardinality: string;
+    /** The feature name. */
+    displayName: string;
+    /** The target object type (the feature's value sort). */
+    linkedObjectTypeApiName: string;
+    /** The source object type (the sort declaring the feature). */
+    objectTypeApiName: string;
+}
+/** Response for `GET /api/v1/ontology/link-types`. */
+interface LinkTypeListResponse$1 {
+    /**
+     * Number of link types returned.
+     * @min 0
+     */
+    count: number;
+    /** The projected link types. */
+    linkTypes: LinkTypeDto[];
+}
 /** Response for listing pending action reviews */
 interface ListActionReviewsResponse$1 {
     /** Whether there are more pages */
@@ -10374,6 +11124,11 @@ interface ListActionReviewsResponse$1 {
      */
     total: number;
 }
+/** Response listing all sort-table bindings. */
+interface ListBindingsResponse$1 {
+    /** Active sort-table bindings. */
+    bindings: BindingSummaryDto$1[];
+}
 /** Request to list available functions */
 interface ListEvalFunctionsRequest$1 {
     /** Optional category filter */
@@ -10398,6 +11153,16 @@ interface ListExternalActionsResponse$1 {
      */
     total: number;
 }
+/** Response from listing all functions registered for a tenant. */
+interface ListFunctionsResponse$1 {
+    /** All functions registered for the requesting tenant, sorted by name. */
+    functions: FunctionSummaryDto$1[];
+    /**
+     * Total count (equals `functions.len()`), surfaced for convenience.
+     * @min 0
+     */
+    total: number;
+}
 /**
  * Response for listing saved goals.
  *
@@ -10438,6 +11203,9 @@ interface ListIngestionSessionsResponse$1 {
      */
     total: number;
 }
+interface ListLevelsResponse$1 {
+    levels: ClassificationLevelDto$1[];
+}
 /** Response for listing patterns. */
 interface ListPatternsResponse$1 {
     /**
@@ -10526,6 +11294,16 @@ interface ListTenantsResponse$1 {
     /** All tenants that have data in the system */
     tenants: TenantInfo[];
 }
+/** A single literal `var = value` for a [`TypedConstraintDto::Forbid`] clause. */
+interface LitDto {
+    /** The required polarity (`true` ⇒ the var is set, `false` ⇒ unset). */
+    value: boolean;
+    /**
+     * The flat decision-variable index.
+     * @min 0
+     */
+    var: number;
+}
 /**
  * A literal for NAF queries - a term with optional negation.
  *
@@ -10605,34 +11383,21 @@ interface MarkdownDocumentDto$1 {
     /** Optional metadata about the document */
     metadata?: null | DocumentMetadataDto$1;
 }
-/** A matched entity from pure OSF search */
+/** An entity matched while resolving a stage. */
 interface MatchedEntityDto$1 {
     /**
-     * Community this entity belongs to
-     * @format uuid
-     */
-    community_id: string;
-    /** Key features as strings */
-    features: Record<string, string>;
-    /**
-     * Match degree (0.0-1.0)
+     * Match confidence in [0, 1].
      * @format double
      */
-    match_degree: number;
-    /** Why this entity matched */
-    match_reason?: string | null;
-    /** Human-readable name (if available) */
-    name?: string | null;
-    /**
-     * Sort ID
-     * @format uuid
-     */
-    sort_id: string;
-    /**
-     * Term ID
-     * @format uuid
-     */
-    term_id: string;
+    confidence: number;
+    /** Why it matched (e.g. "exact", "fuzzy_glb", "salience"). */
+    match_reason: string;
+    /** Display label of the entity. */
+    name: string;
+    /** Sort name the entity belongs to. */
+    sort_name: string;
+    /** Optional TermId (string form). */
+    term_id?: string | null;
 }
 /**
  * Snapshot of the per-tenant Phase 2 materialization sentinel for the
@@ -10724,6 +11489,59 @@ interface MaterializationSummaryDto$1 {
      */
     webhook_actions_created: number;
 }
+/**
+ * Request body for `POST /api/v1/scenarios/materialize`.
+ *
+ * Materializes an already-generated scenario (e.g. the `scenario` payload from
+ * `POST /api/v1/ontology/generate`) into the caller's knowledge base, exactly
+ * as reviewed — sorts, belief instances, rules, goal, and the ontology-declared
+ * engine pipeline. Unlike `create_scenario`, this does **not** call the LLM, so
+ * the materialized graph is byte-for-byte what the client reviewed.
+ */
+interface MaterializeScenarioRequest$1 {
+    /** The domain `GeneratedScenario` JSON to materialize verbatim. */
+    scenario: any;
+}
+/** Response for `POST /api/v1/scenarios/materialize`. */
+interface MaterializeScenarioResponse$1 {
+    /**
+     * Number of belief (instance) Ψ-terms created.
+     * @min 0
+     */
+    beliefs_created: number;
+    /**
+     * Number of generic constraint terms created.
+     * @min 0
+     */
+    constraints_created: number;
+    /**
+     * Number of ontology-declared `pipeline_stage` control-plane terms created.
+     * @min 0
+     */
+    pipeline_stages_created: number;
+    /**
+     * Number of OSF relation edges (`Value::Reference` features) linking instances.
+     * @min 0
+     */
+    relations_created: number;
+    /**
+     * Number of rule Ψ-terms created.
+     * @min 0
+     */
+    rules_created: number;
+    /**
+     * Number of ontology-declared `llm_sensor_point` control-plane terms created.
+     * @min 0
+     */
+    sensor_points_created: number;
+    /**
+     * Number of sorts created or reused.
+     * @min 0
+     */
+    sorts_created: number;
+    /** Non-fatal materialization warnings. */
+    warnings: string[];
+}
 /** Request for math function */
 interface MathFunctionRequest$1 {
     /** Arguments (some may be uninstantiated for bidirectional solving) */
@@ -10973,6 +11791,81 @@ interface MetaSortsResponse$1 {
      * @format uuid
      */
     equality_constraint: string;
+    /**
+     * FD all-different constraint over a list of variables
+     * @format uuid
+     */
+    fd_all_different_constraint: string;
+    /**
+     * FD arithmetic constraint
+     * @format uuid
+     */
+    fd_arithmetic_constraint: string;
+    /**
+     * FD circuit (Hamiltonian) constraint
+     * @format uuid
+     */
+    fd_circuit_constraint: string;
+    /**
+     * Parent sort for all CLP(FD) constraints
+     * @format uuid
+     */
+    fd_constraint: string;
+    /**
+     * FD cumulative scheduling constraint
+     * @format uuid
+     */
+    fd_cumulative_constraint: string;
+    /**
+     * FD disjunctive (no-overlap) constraint
+     * @format uuid
+     */
+    fd_disjunctive_constraint: string;
+    /**
+     * FD domain constraint: variable ∈ [min, max]
+     * @format uuid
+     */
+    fd_domain_constraint: string;
+    /**
+     * FD element constraint: list[index] = value
+     * @format uuid
+     */
+    fd_element_constraint: string;
+    /**
+     * FD global-cardinality constraint
+     * @format uuid
+     */
+    fd_global_cardinality_constraint: string;
+    /**
+     * FD in-set constraint: variable ∈ {values}
+     * @format uuid
+     */
+    fd_in_constraint: string;
+    /**
+     * FD labeling: solve collected FD constraints
+     * @format uuid
+     */
+    fd_labeling_constraint: string;
+    /**
+     * FD lex-chain constraint
+     * @format uuid
+     */
+    fd_lex_chain_constraint: string;
+    /**
+     * FD reified constraint
+     * @format uuid
+     */
+    fd_reified_constraint: string;
+    /**
+     * FD scalar-product constraint: Σ aᵢ·xᵢ ⋚ target
+     * @format uuid
+     */
+    fd_scalar_product_constraint: string;
+    /**
+     * FD sum constraint: Σ vars ⋚ target
+     * @format uuid
+     */
+    fd_sum_constraint: string;
     /**
      * Feature constraint (X.f .= Y)
      * @format uuid
@@ -10983,6 +11876,41 @@ interface MetaSortsResponse$1 {
      * @format uuid
      */
     findall_constraint: string;
+    /**
+     * Edge-classification (Dulmage-Mendelsohn) objective
+     * @format uuid
+     */
+    flow_classify_edges_constraint: string;
+    /**
+     * Parent sort for all CLP(Flow) constraints
+     * @format uuid
+     */
+    flow_constraint: string;
+    /**
+     * Flow-edge constraint: declares a capacitated directed edge
+     * @format uuid
+     */
+    flow_edge_constraint: string;
+    /**
+     * Max-flow objective: bind `flow_value` to the source→sink flow
+     * @format uuid
+     */
+    flow_max_constraint: string;
+    /**
+     * Min-cost-max-flow objective: bind flow value and total cost
+     * @format uuid
+     */
+    flow_min_cost_max_flow_constraint: string;
+    /**
+     * Min-cut objective: bind cut value, edges, and partitions
+     * @format uuid
+     */
+    flow_min_cut_constraint: string;
+    /**
+     * Flow-solve trigger: drains the flow store and runs the algorithm
+     * @format uuid
+     */
+    flow_solve_constraint: string;
     /**
      * Forall constraint (universal quantification)
      * @format uuid
@@ -11627,7 +12555,7 @@ interface NeuroSymbolicStatusResponse$1 {
     status?: object | null;
 }
 /** Translation mode for NL queries */
-type NlQueryMode$1 = "llm" | "constraint" | "cognitive" | "triz";
+type NlQueryMode$1 = "llm" | "constraint" | "cognitive" | "triz" | "grounded_sql";
 /** Natural language query request */
 interface NlQueryRequest$1 {
     /** Optional: confirm a TRIZ session (triggers invention pipeline) */
@@ -11683,7 +12611,14 @@ interface NlQueryResponse$1 {
     results: NlQueryResultItem$1[];
     /** Structured problem from TRIZ session (for user confirmation) */
     structured_problem?: any;
-    /** Whether the query was successful */
+    /**
+     * Whether the pipeline ran end-to-end without error.
+     *
+     * This is **not** a "found-results" flag — an empty `results` array
+     * is a perfectly valid outcome for a query that ran fine but had
+     * no matches in the term store. Use `results.is_empty()` to test
+     * for empty matches, and check `error` for actual failures.
+     */
     success: boolean;
     /** Tool call info (constraint mode) */
     tool_call?: null | ToolCallInfo$1;
@@ -11737,6 +12672,43 @@ type NumberValueDto$1 = {
     /** @format double */
     value: number;
 };
+/** One projected object type. */
+interface ObjectTypeDto {
+    /** Sort name (Palantir object-type apiName). */
+    apiName: string;
+    /** Sort description, if any. */
+    description?: string | null;
+    /** Human-facing name (the sort name). */
+    displayName: string;
+    /** apiNames of the supersorts this sort refines (the interfaces it implements). */
+    implementsInterfaceTypes: string[];
+    /** Primary key — Ψ-terms are identified by their `TermId`. */
+    primaryKey: string[];
+    /** Appropriate scalar features projected as properties. */
+    properties: PropertyDto[];
+    /** Lifecycle status — always `ACTIVE` for a live sort. */
+    status: string;
+}
+/** Response for `GET /api/v1/ontology/object-types`. */
+interface ObjectTypeListResponse$1 {
+    /**
+     * Number of object types returned.
+     * @min 0
+     */
+    count: number;
+    /** The projected object types. */
+    objectTypes: ObjectTypeDto[];
+}
+/** Linear objective.  Omit to run feasibility-only. */
+interface Objective$1 {
+    coefficients?: Record<string, number>;
+    /** @format double */
+    constant?: number;
+    /** Direction of the objective function. */
+    sense: ObjectiveSense$1;
+}
+/** Direction of the objective function. */
+type ObjectiveSense$1 = "minimize" | "maximize";
 interface ObserveMultiRequest$1 {
     /** Map of variable name to value */
     observations: Record<string, number>;
@@ -12079,6 +13051,14 @@ interface OsfqlRequest$1 {
      * ```
      */
     query: string;
+    /**
+     * Opt into **reactive (streaming) mode**: after the program runs, any
+     * suspended `AWAIT` demon whose trigger is now satisfied fires
+     * automatically — no explicit `RELEASE RESIDUATIONS` needed. Defaults to
+     * `false` (demons stay suspended until an explicit RELEASE), so existing
+     * clients are byte-identical.
+     */
+    reactive?: boolean;
 }
 /** Response from executing an OSFQL program. */
 interface OsfqlResponse$1 {
@@ -12144,6 +13124,15 @@ interface OversightAlertDto$1 {
      */
     step_index: number;
 }
+/** A typed action parameter (named feature with an appropriateness type). */
+interface ParamSpecDto {
+    /** Feature name. */
+    name: string;
+    /** Appropriateness type: `integer`, `real`, `string`, `boolean`, or `any`. */
+    param_type: string;
+    /** Whether the input must be bound for the action to be `Ready`. */
+    required?: boolean;
+}
 /** Metadata extracted from a parsed document */
 interface ParsedDocumentMetadataDto$1 {
     /** Document author */
@@ -12845,6 +13834,20 @@ interface ProofTraceDto$1 {
     /** Suggested fixes from the proof engine */
     suggestions: FixSuggestionDto$1[];
 }
+/**
+ * A projected property — one appropriate *scalar* feature of a sort.
+ *
+ * Referring features (whose value is another sort) are projected as
+ * [`link_types`] instead, so they never appear here.
+ */
+interface PropertyDto {
+    /** The feature name (Palantir property apiName). */
+    apiName: string;
+    /** The declared value-type hint, or `"string"` when unspecified. */
+    dataType: string;
+    /** Whether the feature is required by the sort's appropriateness conditions. */
+    required: boolean;
+}
 /** A single provenance entry mapping a citation to a source fact. */
 interface ProvenanceDto {
     /** Human-readable description of the source. */
@@ -13071,7 +14074,7 @@ interface QueueMetricsResponse {
     worker_utilization_pct?: number | null;
 }
 /** RDF format DTO */
-type RdfFormatDto$1 = "turtle" | "n_triples" | "rdf_xml" | "json_ld";
+type RdfFormatDto$1 = "turtle" | "n_triples" | "rdf_xml" | "json_ld" | "trig" | "nquads";
 /** Request to re-extract entities from a document */
 interface ReExtractRequest$1 {
     /** Document ID to re-extract from */
@@ -13106,6 +14109,18 @@ interface ReExtractResponse {
      */
     pending_review_count: number;
 }
+interface ReadableTermDto$1 {
+    id: string;
+    marking: string;
+}
+interface ReadableTermsResponse$1 {
+    clearance: string;
+    readable: ReadableTermDto$1[];
+    /** @min 0 */
+    readable_count: number;
+    /** @min 0 */
+    withheld_count: number;
+}
 /** Response payload for `POST /api/v1/admin/derived-facts/rebuild/{tenant_id}`. */
 interface RebuildDerivedFactsResponse {
     /**
@@ -13649,7 +14664,7 @@ interface ResiduationGoalDto$1 {
     result_target?: string | null;
 }
 /** Kind of residuation to visualize */
-type ResiduationKind$1 = "inference" | "fuzzy" | "extraction" | "all";
+type ResiduationKind$1 = "inference" | "fuzzy" | "extraction" | "naf_failure" | "all";
 /** Request for residuation check */
 interface ResiduationRequest$1 {
     /**
@@ -14483,6 +15498,18 @@ interface RuleAggregatorDto {
     /** Feature name whose value is aggregated within each group. */
     target: string;
 }
+/** The full certification result returned to the caller. */
+interface RuleBaseCertificateDto {
+    /** The order-independence guarantee (or the conflicting rule pair). */
+    confluence: ConfluenceDto;
+    /**
+     * `true` iff the rule base both terminates and is order-independent — the
+     * complete "won't loop, order-independent" guarantee.
+     */
+    fully_certified: boolean;
+    /** The termination guarantee (or why it could not be established). */
+    termination: TerminationDto;
+}
 /** A rule clause (OSF clause) */
 interface RuleClauseDto$1 {
     /** Constraints on variables in this clause */
@@ -14511,6 +15538,23 @@ interface RuleDto$1 {
     id: string;
     is_fact: boolean;
 }
+/** A single rule entry with head, body, and optional certainty. */
+interface RuleEntryDto$1 {
+    /** The body (antecedents) of the rule. */
+    body: PsiTermDto$1[];
+    /**
+     * Optional certainty/confidence for the rule.
+     * @format double
+     */
+    certainty?: number | null;
+    /** The head (consequent) of the rule. */
+    head: PsiTermDto$1;
+    /**
+     * Rule term ID.
+     * @format uuid
+     */
+    rule_id: string;
+}
 /** Response with rule store info */
 interface RuleStoreResponse$1 {
     /** @min 0 */
@@ -14661,6 +15705,26 @@ interface ScenarioSummaryDto$1 {
      */
     sorts_created: number;
 }
+/**
+ * Response to a pin: the cells whose class changed, plus the full updated
+ * classification for convenience.
+ */
+interface SchedulingDeltaResponse$1 {
+    /** The full classification after the pin. */
+    classification: ClassificationDto;
+    /** Cells that became `confirmed_false` on this pin. */
+    newly_confirmed_false: number[];
+    /** Cells that became `confirmed_true` on this pin (incl. the pinned cell). */
+    newly_confirmed_true: number[];
+    /**
+     * In optimize mode, the optimum `Σ weight·var` after this assumption;
+     * absent for pure-feasibility models. The optimum can drop as pins shrink
+     * the optimal set, so always trust `classification` (the full state) for
+     * repaint — the optimize delta can also un-confirm cells.
+     * @format int64
+     */
+    total_score?: number | null;
+}
 /**
  * A scheduling feasibility request.
  *
@@ -14752,6 +15816,20 @@ interface SchedulingOptimizeResponse$1 {
      */
     total_score: number;
 }
+/** Response carrying a session id and its current classification. */
+interface SchedulingSessionResponse$1 {
+    /** The current per-cell trichotomy. */
+    classification: ClassificationDto;
+    /** Opaque session id. */
+    session_id: string;
+    /**
+     * In optimize mode (the request carried an `objective`), the optimum
+     * `Σ weight·var` over the optimal completions at the current pins; absent
+     * for pure-feasibility models.
+     * @format int64
+     */
+    total_score?: number | null;
+}
 /** Top-level request status. */
 type SchedulingStatusDto = "feasible" | "infeasible";
 /** Request to search communities */
@@ -15222,6 +16300,8 @@ interface SolutionDto$1 {
     /** The substitution that satisfies the query */
     substitution: HomoiconicSubstitutionDto$1;
 }
+/** Status reported by the solver. */
+type SolutionStatus$1 = "optimal" | "feasible" | "infeasible" | "unbounded" | "unknown";
 /** Request to solve a constraint problem */
 interface SolveConstraintRequest$1 {
     constraints: ArithmeticConstraintDto$1[];
@@ -15263,6 +16343,66 @@ interface SolveFlowNetworkResponse$1 {
      */
     total_flow?: number | null;
 }
+/** Request body for `POST /api/v1/solver/solve`. */
+interface SolveProblemRequest$1 {
+    constraints?: LinearConstraint$2[];
+    /**
+     * Relative MIP gap tolerance (e.g. `0.01` for 1 %).  `0.0` means
+     * "solve to proven optimum".
+     * @format double
+     */
+    gap_tolerance?: number | null;
+    /**
+     * Backend-selection hint.  `Auto` (default) routes CP-SAT for fully
+     * discrete problems and HiGHS for any continuous variable.
+     */
+    hint?: SolverHint$1;
+    objective?: null | Objective$1;
+    /**
+     * Wall-clock limit per solve, in milliseconds.  Defaults server-side
+     * to 30 000.
+     * @format int64
+     * @min 0
+     */
+    time_limit_ms?: number | null;
+    variables: VariableSpec$1[];
+}
+/** Response body for `POST /api/v1/solver/solve`. */
+interface SolveProblemResponse$1 {
+    /** Optional diagnostic message (e.g. when status is `Unknown`). */
+    message?: string | null;
+    /** @format double */
+    objective_value?: number | null;
+    /**
+     * Wall-clock solve time inside the solver service, in milliseconds.
+     * @format double
+     */
+    solve_time_ms: number;
+    /** `"cp_sat"` or `"highs"`. */
+    solver: string;
+    /** Status reported by the solver. */
+    status: SolutionStatus$1;
+    /** Variable-name → optimal value.  Empty for infeasible/unbounded. */
+    values: Record<string, number>;
+}
+/**
+ * Response body for `GET /api/v1/solver/health`. Typed so the OpenAPI
+ * audit (`openapi_audit::should_have_no_untyped_response_bodies`)
+ * stays green — a liveness probe still gets a schema-described shape
+ * rather than an opaque `serde_json::Value`.
+ */
+interface SolverHealthResponse$1 {
+    /**
+     * Liveness marker — `"ok"` when the upstream solver service
+     * responded with a 2xx to its `/health` endpoint.
+     */
+    status: string;
+}
+/**
+ * Backend-selection hint.  `Auto` (default) routes CP-SAT for fully
+ * discrete problems and HiGHS for any continuous variable.
+ */
+type SolverHint$1 = "auto" | "prefer_cp" | "prefer_lp";
 /** Response with ancestor sorts */
 interface SortAncestorsResponse {
     ancestors: SortInfoDto$1[];
@@ -15464,6 +16604,12 @@ interface SortDto$1 {
     bound_constraints?: BoundConstraintDto$1[];
     /** Human-readable description for semantic search */
     description?: string | null;
+    /**
+     * SKOS external-ontology alignments (e.g. BFO/CCO) attached to this sort.
+     * Populated by the upper-ontology aligner; makes each correspondence a live,
+     * queryable property of the sort rather than a separate static export.
+     */
+    external_matches?: ExternalMatchDto$1[];
     /** Feature declarations that define the sort's schema */
     feature_declarations?: FeatureDescriptorDto$1[];
     /**
@@ -16757,6 +17903,29 @@ interface TemporalPlanResponse$1 {
     /** Selected term IDs in temporal order */
     selected_term_ids: string[];
 }
+/**
+ * A temporal rule over one agent's ordered slot timeline (mirrors the domain
+ * `TemporalRule`). Tagged by `type`.
+ */
+type TemporalRuleDto = {
+    type: "no_consec";
+} | {
+    /** Whether at most one slot may be worked per day. */
+    max_1_shift_per_day: boolean;
+    /**
+     * Worked-slot (or worked-day) cap.
+     * @min 0
+     */
+    max_days: number;
+    type: "capacity";
+} | {
+    /**
+     * Maximum consecutive worked nights.
+     * @min 0
+     */
+    k: number;
+    type: "max_consecutive_nights";
+};
 /** Variable-length temporal feature sequence in row-major form. */
 interface TemporalSequenceDto {
     /** Row-major buffer of length `seq_len * input_dim`. */
@@ -16829,6 +17998,17 @@ interface TermDto$1 {
      */
     tenant_id: string;
 }
+/** One edit in the action's atomic multi-term batch. */
+type TermEditDto = {
+    /** Create or overwrite a term (reuses the standard term-creation body). */
+    put: CreateTermRequest$1;
+} | {
+    /**
+     * Remove an existing term by id.
+     * @format uuid
+     */
+    remove: string;
+};
 /** Response for term existence check */
 interface TermExistsResponse {
     /** Whether the term exists */
@@ -16917,6 +18097,36 @@ interface TermTranslationDto {
     copied_id: string;
     original_id: string;
 }
+/** Termination half of the certificate. */
+interface TerminationDto {
+    /**
+     * Whether any rule invents fresh values (creating new entities), present only
+     * when established via the ranking function.
+     */
+    creates_new_values?: boolean | null;
+    /**
+     * When termination could not be established and an obstruction was found, the
+     * human-readable cycle of interacting positions that can grow without bound.
+     */
+    diverging_cycle?: any[] | null;
+    /**
+     * The deepest chain of freshly-created values any reasoning step can produce
+     * (the ranking-function bound). `0` means the rules never invent new values
+     * — reasoning is bounded by the existing data. Present only when terminating
+     * via the ranking function.
+     * @format int32
+     * @min 0
+     */
+    max_recursion_depth?: number | null;
+    /**
+     * How termination was established: `"bounded-recursion"` (a ranking function
+     * bounds value creation), `"decidable-fragment:<name>"` (a recognised
+     * terminating rule class), or `"undetermined"`.
+     */
+    method: string;
+    /** `true` iff forward reasoning is guaranteed to reach a fixpoint. */
+    terminates: boolean;
+}
 /** Threshold-based weak anchor for an antecedent gate. */
 interface ThresholdAnchorDto {
     /**
@@ -17132,6 +18342,27 @@ interface TrajectoryStepDto$1 {
     /** Specific tool identifier (if different from action) */
     tool_used?: string | null;
 }
+/** Request to transpile an OSFQL query to SQL. */
+interface TranspileRequest$1 {
+    /** SQL dialect: "postgres", "mysql", or "sqlite". */
+    dialect?: string;
+    /** OSFQL query to transpile. */
+    osfql: string;
+}
+/** Response from OSFQL-to-SQL transpilation. */
+interface TranspileResponse$1 {
+    /** Whether the entire plan is SQL-transpilable. */
+    fully_transpilable: boolean;
+    /**
+     * Number of parameters in the generated SQL.
+     * @min 0
+     */
+    param_count: number;
+    /** Source ID the query targets. */
+    source_id?: string | null;
+    /** Generated SQL query. */
+    sql: string;
+}
 /** Request for trigger dependency graph */
 interface TriggerDependencyRequest$1 {
     /** Whether to generate DOT output */
@@ -17213,6 +18444,63 @@ interface TrizRecordOutcomeResponse {
      */
     updated_confidence: number;
 }
+/**
+ * One structured constraint over the flat decision variables (mirrors the
+ * domain `TypedConstraint`). Tagged by `type`; variable ids are flat indices
+ * the caller assigns (the choice-point layout defines the ranges).
+ */
+type TypedConstraintDto = {
+    /**
+     * Optional upper bound (`null` = none).
+     * @min 0
+     */
+    max?: number | null;
+    /**
+     * Lower bound (`0` = none).
+     * @min 0
+     */
+    min: number;
+    type: "global_cardinality";
+    /** The variables summed. */
+    vars: number[];
+} | {
+    /** The literals of the clause. */
+    lits: LitDto[];
+    type: "forbid";
+} | {
+    type: "pin";
+    /**
+     * The variable to fix `true`.
+     * @min 0
+     */
+    var: number;
+} | {
+    /** `available[L]` — `false` where the slot is structurally unavailable. */
+    available: boolean[];
+    /**
+     * Days in the timeline.
+     * @min 0
+     */
+    days: number;
+    /** Temporal rules enforced over the timeline. */
+    rules: TemporalRuleDto[];
+    /**
+     * Shifts per day.
+     * @min 0
+     */
+    shifts: number;
+    type: "regular";
+    /** The agent's variables in slot order. */
+    vars: number[];
+} | {
+    type: "all_different";
+    /** The mutually-exclusive variables. */
+    vars: number[];
+} | {
+    /** The boolean-valued expression asserted true. */
+    expr: BoolExprDto;
+    type: "arithmetic";
+};
 /** DTO for UIAction — all actions reference OSFQL execution */
 type UIActionDto$1 = {
     field_types: Record<string, string>;
@@ -17789,7 +19077,7 @@ type ValidationTypeDto$1 = {
 /**
  * ValueDto
  * Value in a term feature. Discriminated by 'type' field.
- * Variants: String, Integer, Real, Boolean, Uninstantiated, Reference, List, FuzzyScalar, FuzzyNumber, Set.
+ * Variants: String, Integer, Real, Boolean, Uninstantiated, Reference, SortId, List, FuzzyScalar, FuzzyNumber, Set.
  */
 type ValueDto$1 = {
     type: "String";
@@ -17811,9 +19099,19 @@ type ValueDto$1 = {
     type: "Reference";
     /** @format uuid */
     value: string;
+} | {
+    type: "SortId";
+    /** @format uuid */
+    value: string;
 } | {
     type: "List";
     value: ValueDto$1[];
+} | {
+    type: "Domain";
+    value: ValueDto$1[];
+} | {
+    type: "Choice";
+    value: ValueDto$1[];
 } | {
     type: "FuzzyScalar";
     value: {
@@ -17871,6 +19169,17 @@ type ValuePatternDto$1 = {
     type: "bind";
     variable: string;
 };
+/**
+ * Domain of a variable.  CP-SAT handles `Integer` and `Binary`; HiGHS
+ * handles all three.  The solver service picks the backend based on the
+ * `hint` field and the variable kinds present.
+ */
+type VarKind$1 = "continuous" | "integer" | "binary";
+/**
+ * Per-variable classification — the ILP analog of flow's edge
+ * classification (Dulmage-Mendelsohn).
+ */
+type VariableClassification$1 = "always_used" | "sometimes_used" | "never_used";
 /**
  * Feasibility of a single binary variable in the constraint space.
  *
@@ -17904,6 +19213,27 @@ interface VariableFeasibilityDto$1 {
      */
     verified?: boolean;
 }
+/**
+ * A single decision variable.  Names must be unique within a problem
+ * and are echoed verbatim in the response `values` map.
+ */
+interface VariableSpec$1 {
+    /** Variable kind.  Defaults to `Continuous`. */
+    kind?: VarKind$1;
+    /**
+     * Lower bound.  Use `f64::NEG_INFINITY` for unbounded below.
+     * @format double
+     */
+    lower_bound?: number;
+    /** Caller-chosen identifier.  Must be unique. */
+    name: string;
+    /**
+     * Upper bound.  Use `f64::INFINITY` for unbounded above.  Ignored
+     * for `Binary` (forced to 1).
+     * @format double
+     */
+    upper_bound?: number;
+}
 /** Result of verbalizing a single PsiTerm. */
 interface VerbalizationResultDto$1 {
     /**
@@ -20294,7 +21624,7 @@ declare namespace terms {
 }
 
 /** Translation mode for natural language queries. */
-type NlQueryMode = 'llm' | 'constraint' | 'cognitive' | 'triz';
+type NlQueryMode = 'llm' | 'constraint' | 'cognitive' | 'triz' | 'grounded_sql';
 /** A result item from a natural language query. */
 interface NlQueryResultItem {
     /** Term ID. */
@@ -20349,20 +21679,16 @@ interface OsfSearchRequest {
  * A matched entity in a structured search result.
  */
 interface MatchedEntityDto {
-    /** Term ID. */
-    termId: string;
-    /** Sort ID. */
-    sortId: string;
-    /** Community this entity belongs to. */
-    communityId: string;
-    /** Human-readable name (if available). */
-    name?: string | null;
-    /** Key features as strings. */
-    features: Record<string, string>;
-    /** Match degree (0.0-1.0). */
-    matchDegree: number;
-    /** Why this entity matched. */
-    matchReason?: string | null;
+    /** Match confidence in [0, 1]. */
+    confidence: number;
+    /** Why it matched (e.g. `"exact"`, `"fuzzy_glb"`, `"salience"`). */
+    matchReason: string;
+    /** Display label of the entity. */
+    name: string;
+    /** Sort name the entity belongs to. */
+    sortName: string;
+    /** Optional term ID (string form). */
+    termId?: string | null;
 }
 /**
  * A discovered relation between entities in a structured search result.
@@ -21227,6 +22553,16 @@ declare class Inference<SecurityDataType = unknown> {
      * @secure
      */
     getMetaSorts: (params?: RequestParams) => Promise<HttpResponse<MetaSortsResponse$1, any>>;
+    /**
+     * @description # Authorization Requires X-Tenant-Id header.
+     *
+     * @tags inference
+     * @name GetRules
+     * @summary Get all rules (clauses with antecedents) for a tenant
+     * @request GET:/api/v1/inference/rules/{tenant_id}
+     * @secure
+     */
+    getRules: (tenantId: 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.
      *
@@ -21829,6 +23165,30 @@ interface ListGoalsResponse {
     /** List of saved goals. */
     goals: GoalSummaryDto[];
 }
+/**
+ * A single stored rule (clause with antecedents).
+ *
+ * @remarks
+ * Both `head` and `body` are homoiconic {@link PsiTermDto} values
+ * (untagged feature-value representation).
+ */
+interface RuleEntryDto {
+    /** Rule term ID (UUID). */
+    ruleId: string;
+    /** The head (consequent) of the rule. */
+    head: PsiTermDto;
+    /** The body (antecedents) of the rule. */
+    body: PsiTermDto[];
+    /** Optional certainty/confidence for the rule. */
+    certainty?: number | null;
+}
+/** Response listing all rules for a tenant. */
+interface GetRulesResponse {
+    /** Total number of rules. */
+    count: number;
+    /** The rules (clauses with antecedents). */
+    rules: RuleEntryDto[];
+}
 /**
  * Response listing the meta-sorts (built-in system sorts) for inference.
  *
@@ -22038,6 +23398,7 @@ type inference_ForwardChainResponse = ForwardChainResponse;
 type inference_FuzzyProveRequest = FuzzyProveRequest;
 type inference_FuzzyProveResponse = FuzzyProveResponse;
 type inference_GetFactsResponse = GetFactsResponse;
+type inference_GetRulesResponse = GetRulesResponse;
 type inference_GoalDto = GoalDto;
 type inference_GoalSummaryDto = GoalSummaryDto;
 type inference_GuardOp = GuardOp;
@@ -22049,12 +23410,13 @@ type inference_NafProveRequest = NafProveRequest;
 type inference_NafProveResponse = NafProveResponse;
 type inference_ProofDto = ProofDto;
 type inference_ProvenanceTagDto = ProvenanceTagDto;
+type inference_RuleEntryDto = RuleEntryDto;
 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_FactConfidenceEntry as FactConfidenceEntry, inference_ForwardChainRequest as ForwardChainRequest, inference_ForwardChainResponse as ForwardChainResponse, inference_FuzzyProveRequest as FuzzyProveRequest, inference_FuzzyProveResponse as FuzzyProveResponse, inference_GetFactsResponse as GetFactsResponse, 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_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_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_RuleEntryDto as RuleEntryDto, inference_SolutionDto as SolutionDto, inference_TaggedDerivedFact as TaggedDerivedFact, inference_TaggedForwardChainRequest as TaggedForwardChainRequest, inference_TaggedForwardChainResponse as TaggedForwardChainResponse };
 }
 
 /**
@@ -22130,6 +23492,28 @@ declare class InferenceClient {
      * @returns Clear result with facts_cleared count.
      */
     clearFacts(): Promise<ClearFactsResponse>;
+    /**
+     * Get all stored rules (clauses with antecedents) for the tenant.
+     *
+     * @returns Rules with a total count. Each rule's `head` and `body` are {@link PsiTermDto} values.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * The tenant is taken from the client's configured tenant ID (used for the
+     * `{tenant_id}` path parameter), matching the sibling fact-retrieval methods.
+     *
+     * Responses use the homoiconic {@link PsiTermDto} representation.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.inference.getRules();
+     * console.log(result.count); // number of stored rules
+     * for (const rule of result.rules) {
+     *   console.log(rule.head.display, '<-', rule.body.map((b) => b.display));
+     * }
+     * ```
+     */
+    getRules(): Promise<GetRulesResponse>;
     /**
      * Query for matching data by searching rules and facts backwards from a goal pattern.
      *
@@ -25135,7 +26519,7 @@ type GlbLubOperation = 'glb' | 'lub';
 /**
  * Kind of residuation to visualize.
  */
-type ResiduationKind = 'inference' | 'fuzzy' | 'extraction' | 'all';
+type ResiduationKind = 'inference' | 'fuzzy' | 'extraction' | 'naf_failure' | 'all';
 /**
  * State filter for residuation visualization.
  */
@@ -26386,6 +27770,16 @@ declare class Collections<SecurityDataType = unknown> {
      * @secure
      */
     createCollection: (data: CreateCollectionRequest$1, params?: RequestParams) => Promise<HttpResponse<CollectionResponse, void>>;
+    /**
+     * @description The term is created through the standard term path (sort validation + reactive constraints apply), then assigned to the collection so `query_terms_in_collection` can resolve it. The tenant is taken from the `X-Tenant-Id` header; `collection_id` comes from the request body.
+     *
+     * @tags collections
+     * @name CreateTermInCollection
+     * @summary Create a term scoped to a collection.
+     * @request POST:/api/v1/terms/in-collection
+     * @secure
+     */
+    createTermInCollection: (data: CreateTermInCollectionRequest$1, params?: RequestParams) => Promise<HttpResponse<TermResponse$1, void>>;
     /**
      * No description
      *
@@ -26466,12 +27860,46 @@ declare class Collections<SecurityDataType = unknown> {
      * @secure
      */
     listCollections: (namespaceId: string, params?: RequestParams) => Promise<HttpResponse<CollectionListResponse, void>>;
+    /**
+     * @description `?include_children=true` widens the result to the namespace subtree. `?from=<ns>` performs a cross-namespace query: terms are returned only if the `from` namespace may access this namespace under the visibility rules.
+     *
+     * @tags collections
+     * @name ListNamespaceTerms
+     * @summary List terms scoped to a namespace.
+     * @request GET:/api/v1/namespaces/{namespace_id}/terms
+     * @secure
+     */
+    listNamespaceTerms: (namespaceId: string, query?: {
+        /**
+         * Querying namespace (visibility gate)
+         * @format uuid
+         */
+        from?: string;
+        /** Include descendant namespaces */
+        include_children?: boolean;
+    }, params?: RequestParams) => Promise<HttpResponse<TermListResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags collections
+     * @name ListVisibleNamespaceTerms
+     * @summary List the terms visible within a namespace's own hierarchy (the namespace plus all descendant namespaces). A namespace can always see terms inside its own subtree.
+     * @request GET:/api/v1/namespaces/{namespace_id}/visible-terms
+     * @secure
+     */
+    listVisibleNamespaceTerms: (namespaceId: string, query?: {
+        /**
+         * Querying namespace
+         * @format uuid
+         */
+        from?: string;
+    }, params?: RequestParams) => Promise<HttpResponse<TermListResponse$1, void>>;
     /**
      * No description
      *
      * @tags collections
      * @name QueryTermsByCollectionPath
-     * @summary Query terms by collection path prefix (placeholder - needs term integration)
+     * @summary Query terms in every collection whose path matches a prefix within a namespace (e.g. `/projects/alpha` matches `/projects/alpha` and its sub-paths). Member terms of all matching collections are hydrated.
      * @request POST:/api/v1/collections/query/by-path
      * @secure
      */
@@ -26481,7 +27909,7 @@ declare class Collections<SecurityDataType = unknown> {
      *
      * @tags collections
      * @name QueryTermsInCollection
-     * @summary Query terms in a collection (placeholder - needs term integration)
+     * @summary Query terms scoped to a collection (optionally including descendant collections). Resolves the collection's member terms and hydrates each from the tenant term store.
      * @request POST:/api/v1/collections/query/in-collection
      * @secure
      */
@@ -26498,6 +27926,27 @@ declare class Collections<SecurityDataType = unknown> {
     updateCollection: (id: string, data: UpdateCollectionRequest$1, params?: RequestParams) => Promise<HttpResponse<void, void>>;
 }
 
+/**
+ * Request to create a term scoped to a collection.
+ *
+ * @remarks
+ * Features use the tagged {@link ValueDto} format (`{"type": "String", "value": "hello"}`).
+ * Use `Value.*` builders to construct feature values. The term is created through the
+ * standard term path (sort validation + reactive constraints apply) and then assigned
+ * to the collection.
+ */
+interface CreateTermInCollectionRequest {
+    /** Collection UUID to add the term to. */
+    collectionId: string;
+    /** Namespace UUID. */
+    namespaceId: string;
+    /** Sort (type) UUID for the term. */
+    sortId: string;
+    /** Tenant UUID. */
+    tenantId: string;
+    /** Named features with tagged values. */
+    features: Record<string, ValueDto>;
+}
 /**
  * Request to create a collection.
  */
@@ -26544,9 +27993,10 @@ interface CollectionDto {
 
 type collections_CollectionDto = CollectionDto;
 type collections_CreateCollectionRequest = CreateCollectionRequest;
+type collections_CreateTermInCollectionRequest = CreateTermInCollectionRequest;
 type collections_UpdateCollectionRequest = UpdateCollectionRequest;
 declare namespace collections {
-  export type { collections_CollectionDto as CollectionDto, collections_CreateCollectionRequest as CreateCollectionRequest, collections_UpdateCollectionRequest as UpdateCollectionRequest };
+  export type { collections_CollectionDto as CollectionDto, collections_CreateCollectionRequest as CreateCollectionRequest, collections_CreateTermInCollectionRequest as CreateTermInCollectionRequest, collections_UpdateCollectionRequest as UpdateCollectionRequest };
 }
 
 /**
@@ -26632,6 +28082,69 @@ declare class CollectionsClient {
      * @returns Array of root collections.
      */
     getRootCollections(namespaceId: string): Promise<CollectionDto[]>;
+    /**
+     * Create a term scoped to a collection.
+     *
+     * @param request - Term creation parameters, including the target collection.
+     * @returns The created term wrapped in a {@link TermResponse}, including its
+     *   validation state and any witness proofs or residuated witnesses.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * The term is created through the standard term path (sort validation +
+     * reactive constraints apply), then assigned to the collection so that
+     * collection queries can resolve it. Features use the tagged `ValueDto`
+     * format — use `Value.*` builders to construct feature values. The tenant is
+     * taken from the `X-Tenant-Id` header; `collectionId` comes from the request.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.collections.createTermInCollection({
+     *   collectionId: 'coll-uuid',
+     *   namespaceId: 'ns-uuid',
+     *   sortId: 'sort-uuid',
+     *   tenantId: 'tenant-uuid',
+     *   features: { name: Value.string('Alice') },
+     * });
+     * console.log(result.term.id);
+     * ```
+     */
+    createTermInCollection(request: CreateTermInCollectionRequest): Promise<TermResponse>;
+    /**
+     * List terms scoped to a namespace.
+     *
+     * @param namespaceId - Namespace UUID.
+     * @returns The matching terms with a total count.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Features in the returned terms use the tagged `ValueDto` format.
+     *
+     * @example
+     * ```typescript
+     * const { terms, count } = await client.collections.listNamespaceTerms('ns-uuid');
+     * console.log(`${count} terms`);
+     * ```
+     */
+    listNamespaceTerms(namespaceId: string): Promise<TermListResponse>;
+    /**
+     * List the terms visible within a namespace's own hierarchy.
+     *
+     * @param namespaceId - Namespace UUID.
+     * @returns The matching terms with a total count.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Returns terms inside the namespace plus all descendant namespaces; a
+     * namespace can always see terms inside its own subtree. Features in the
+     * returned terms use the tagged `ValueDto` format.
+     *
+     * @example
+     * ```typescript
+     * const { terms } = await client.collections.listVisibleNamespaceTerms('ns-uuid');
+     * ```
+     */
+    listVisibleNamespaceTerms(namespaceId: string): Promise<TermListResponse>;
     /**
      * Query terms by collection path prefix.
      *
@@ -34660,6 +36173,16 @@ declare class Scenarios<SecurityDataType = unknown> {
      * @secure
      */
     listScenarios: (params?: RequestParams) => Promise<HttpResponse<ListScenariosResponse$1, any>>;
+    /**
+     * @description Materializes an already-generated GeneratedScenario verbatim (no LLM call): sorts, belief instances, rules, goal, and the ontology-declared engine pipeline. Used by the studio's build wizard to persist exactly what was reviewed so it is immediately queryable in chat.
+     *
+     * @tags scenarios
+     * @name MaterializeScenario
+     * @summary Materialize a pre-generated scenario into the knowledge base
+     * @request POST:/api/v1/scenarios/materialize
+     * @secure
+     */
+    materializeScenario: (data: MaterializeScenarioRequest$1, params?: RequestParams) => Promise<HttpResponse<MaterializeScenarioResponse$1, void>>;
     /**
      * @description Adds new sorts, beliefs, rules, constraints, guard constraints, temporal constraints, and/or webhook actions to an existing scenario without re-creating everything from scratch.
      *
@@ -34845,6 +36368,38 @@ interface GetScenarioResponse {
     /** Number of webhook actions created during materialization. */
     webhookActionsCreated: number;
 }
+/**
+ * Request to materialize an already-generated scenario verbatim (no LLM call).
+ *
+ * @remarks
+ * Used to persist a pre-generated `GeneratedScenario` exactly as reviewed.
+ * The `scenario` field is the opaque domain `GeneratedScenario` JSON object.
+ */
+interface MaterializeScenarioRequest {
+    /** The domain `GeneratedScenario` JSON to materialize verbatim. */
+    scenario: unknown;
+}
+/**
+ * Response from materializing a pre-generated scenario.
+ */
+interface MaterializeScenarioResponse {
+    /** Number of belief (instance) Psi-terms created. */
+    beliefsCreated: number;
+    /** Number of generic constraint terms created. */
+    constraintsCreated: number;
+    /** Number of ontology-declared `pipeline_stage` control-plane terms created. */
+    pipelineStagesCreated: number;
+    /** Number of OSF relation edges (`Value::Reference` features) linking instances. */
+    relationsCreated: number;
+    /** Number of rule Psi-terms created. */
+    rulesCreated: number;
+    /** Number of ontology-declared `llm_sensor_point` control-plane terms created. */
+    sensorPointsCreated: number;
+    /** Number of sorts created or reused. */
+    sortsCreated: number;
+    /** Non-fatal materialization warnings. */
+    warnings: string[];
+}
 /**
  * Request to incrementally update a scenario.
  *
@@ -34978,6 +36533,8 @@ type scenarios_GetScenarioResponse = GetScenarioResponse;
 type scenarios_LayerResultSummaryDto = LayerResultSummaryDto;
 type scenarios_ListScenariosResponse = ListScenariosResponse;
 type scenarios_MaterializationSummaryDto = MaterializationSummaryDto;
+type scenarios_MaterializeScenarioRequest = MaterializeScenarioRequest;
+type scenarios_MaterializeScenarioResponse = MaterializeScenarioResponse;
 type scenarios_ScenarioSummaryDto = ScenarioSummaryDto;
 type scenarios_UpdateScenarioRequest = UpdateScenarioRequest;
 type scenarios_UpdateScenarioResponse = UpdateScenarioResponse;
@@ -34985,7 +36542,7 @@ type scenarios_VerificationStepDto = VerificationStepDto;
 type scenarios_VerifyScenarioRequest = VerifyScenarioRequest;
 type scenarios_VerifyScenarioResponse = VerifyScenarioResponse;
 declare namespace scenarios {
-  export type { scenarios_ClarificationQuestionDto as ClarificationQuestionDto, scenarios_CreateScenarioRequest as CreateScenarioRequest, scenarios_CreateScenarioResponse as CreateScenarioResponse, scenarios_CycleOutcomeSummaryDto as CycleOutcomeSummaryDto, scenarios_FormalVerdictDto as FormalVerdictDto, scenarios_GetScenarioResponse as GetScenarioResponse, scenarios_LayerResultSummaryDto as LayerResultSummaryDto, scenarios_ListScenariosResponse as ListScenariosResponse, scenarios_MaterializationSummaryDto as MaterializationSummaryDto, scenarios_ScenarioSummaryDto as ScenarioSummaryDto, scenarios_UpdateScenarioRequest as UpdateScenarioRequest, scenarios_UpdateScenarioResponse as UpdateScenarioResponse, scenarios_VerificationStepDto as VerificationStepDto, scenarios_VerifyScenarioRequest as VerifyScenarioRequest, scenarios_VerifyScenarioResponse as VerifyScenarioResponse };
+  export type { scenarios_ClarificationQuestionDto as ClarificationQuestionDto, scenarios_CreateScenarioRequest as CreateScenarioRequest, scenarios_CreateScenarioResponse as CreateScenarioResponse, scenarios_CycleOutcomeSummaryDto as CycleOutcomeSummaryDto, scenarios_FormalVerdictDto as FormalVerdictDto, scenarios_GetScenarioResponse as GetScenarioResponse, scenarios_LayerResultSummaryDto as LayerResultSummaryDto, scenarios_ListScenariosResponse as ListScenariosResponse, scenarios_MaterializationSummaryDto as MaterializationSummaryDto, scenarios_MaterializeScenarioRequest as MaterializeScenarioRequest, scenarios_MaterializeScenarioResponse as MaterializeScenarioResponse, scenarios_ScenarioSummaryDto as ScenarioSummaryDto, scenarios_UpdateScenarioRequest as UpdateScenarioRequest, scenarios_UpdateScenarioResponse as UpdateScenarioResponse, scenarios_VerificationStepDto as VerificationStepDto, scenarios_VerifyScenarioRequest as VerifyScenarioRequest, scenarios_VerifyScenarioResponse as VerifyScenarioResponse };
 }
 
 /**
@@ -35008,6 +36565,29 @@ declare class ScenariosClient {
      * @returns Created scenario (may include interactive questions).
      */
     create(request: CreateScenarioRequest): Promise<CreateScenarioResponse>;
+    /**
+     * Materialize an already-generated scenario verbatim (no LLM call).
+     *
+     * @param req - The pre-generated `GeneratedScenario` JSON to materialize.
+     * @returns Counts of materialized sorts, beliefs, rules, relations, control-plane terms, and any non-fatal warnings.
+     * @throws {ApiError} If the request fails (e.g., malformed scenario JSON).
+     *
+     * @remarks
+     * Materializes the scenario exactly as provided: sorts, belief instances, rules,
+     * goal, and the ontology-declared engine pipeline. Used to persist exactly what
+     * was reviewed so it is immediately queryable.
+     *
+     * The `scenario` field is the opaque domain `GeneratedScenario` JSON object;
+     * no value-level serialization split applies. Response fields are normalized
+     * from snake_case to camelCase.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.scenarios.materializeScenario({ scenario: generated });
+     * console.log(result.sortsCreated, result.beliefsCreated, result.rulesCreated);
+     * ```
+     */
+    materializeScenario(req: MaterializeScenarioRequest): Promise<MaterializeScenarioResponse>;
     /**
      * List all scenarios.
      *
@@ -36895,6 +38475,15 @@ declare class Analysis<SecurityDataType = unknown> {
      * @request POST:/api/v1/analysis/sort-discovery
      */
     analyzeSortDiscovery: (data: SortDiscoveryRequestDto, params?: RequestParams) => Promise<HttpResponse<SortDiscoveryResponseDto, void>>;
+    /**
+     * @description Returns a [`RuleBaseCertificateDto`]: whether forward reasoning is guaranteed to halt (with the ranking-function depth bound), and whether it is order-independent (with the theorem discharged, or a concrete conflicting rule pair). The analysis is read-only over the tenant's knowledge base.
+     *
+     * @tags analysis
+     * @name CertifyRuleBase
+     * @summary Certify the authenticated tenant's rule base.
+     * @request GET:/api/v1/analysis/rule-base/certify
+     */
+    certifyRuleBase: (params?: RequestParams) => Promise<HttpResponse<RuleBaseCertificateDto, any>>;
     /**
      * @description The exploration must be complete (no more questions) before calling this. Creates appropriateness sorts in the hierarchy from the Duquenne-Guigues basis.
      *
@@ -37364,6 +38953,16 @@ declare class Functions<SecurityDataType = unknown> {
      * @secure
      */
     evaluateFunction: (data: EvaluateFunctionRequest$1, params?: RequestParams) => Promise<HttpResponse<EvaluateFunctionResponse$1, void>>;
+    /**
+     * @description This is the discovery counterpart to `register_function`/`evaluate_function`: it projects the tenant's slice of the function sub-lattice into a list of typed signatures (name + arity + clause count) without evaluating anything. The tenant is taken from the authenticated principal (never a body field), honouring the tenancy-scoping invariant.
+     *
+     * @tags functions
+     * @name ListFunctions
+     * @summary Handler to list all functions registered for the authenticated tenant.
+     * @request GET:/api/v1/functions
+     * @secure
+     */
+    listFunctions: (params?: RequestParams) => Promise<HttpResponse<ListFunctionsResponse$1, any>>;
     /**
      * No description
      *
@@ -37566,6 +39165,30 @@ type EvaluateFunctionResponse = {
     resultType: 'Suspend';
     reason: string;
 };
+/**
+ * Summary of a single registered function.
+ *
+ * @remarks
+ * A typed signature (name + arity + clause count) projected from the tenant's
+ * slice of the function sub-lattice. Returned by {@link ListFunctionsResponse}.
+ */
+interface FunctionSummaryDto {
+    /** Number of named arguments the function accepts. */
+    arity: number;
+    /** Number of pattern-matched clauses (tried in order during evaluation). */
+    clausesCount: number;
+    /** Function name (the key used by `POST /functions/evaluate`). */
+    name: string;
+}
+/**
+ * Response listing all functions registered for the authenticated tenant.
+ */
+interface ListFunctionsResponse {
+    /** All functions registered for the requesting tenant, sorted by name. */
+    functions: FunctionSummaryDto[];
+    /** Total count (equals `functions.length`), surfaced for convenience. */
+    total: number;
+}
 
 type functions_BinaryOperatorDto = BinaryOperatorDto;
 type functions_EvaluateFunctionRequest = EvaluateFunctionRequest;
@@ -37574,12 +39197,14 @@ type functions_ExpressionDto = ExpressionDto;
 type functions_FunctionBodyDto = FunctionBodyDto;
 type functions_FunctionClauseDto = FunctionClauseDto;
 type functions_FunctionGuardDto = FunctionGuardDto;
+type functions_FunctionSummaryDto = FunctionSummaryDto;
 type functions_FunctionValueDto = FunctionValueDto;
+type functions_ListFunctionsResponse = ListFunctionsResponse;
 type functions_PatternDto = PatternDto;
 type functions_RegisterFunctionRequest = RegisterFunctionRequest;
 type functions_RegisterFunctionResponse = RegisterFunctionResponse;
 declare namespace functions {
-  export type { functions_BinaryOperatorDto as BinaryOperatorDto, functions_EvaluateFunctionRequest as EvaluateFunctionRequest, functions_EvaluateFunctionResponse as EvaluateFunctionResponse, functions_ExpressionDto as ExpressionDto, functions_FunctionBodyDto as FunctionBodyDto, functions_FunctionClauseDto as FunctionClauseDto, functions_FunctionGuardDto as FunctionGuardDto, functions_FunctionValueDto as FunctionValueDto, functions_PatternDto as PatternDto, functions_RegisterFunctionRequest as RegisterFunctionRequest, functions_RegisterFunctionResponse as RegisterFunctionResponse };
+  export type { functions_BinaryOperatorDto as BinaryOperatorDto, functions_EvaluateFunctionRequest as EvaluateFunctionRequest, functions_EvaluateFunctionResponse as EvaluateFunctionResponse, functions_ExpressionDto as ExpressionDto, functions_FunctionBodyDto as FunctionBodyDto, functions_FunctionClauseDto as FunctionClauseDto, functions_FunctionGuardDto as FunctionGuardDto, functions_FunctionSummaryDto as FunctionSummaryDto, functions_FunctionValueDto as FunctionValueDto, functions_ListFunctionsResponse as ListFunctionsResponse, functions_PatternDto as PatternDto, functions_RegisterFunctionRequest as RegisterFunctionRequest, functions_RegisterFunctionResponse as RegisterFunctionResponse };
 }
 
 /**
@@ -37684,6 +39309,30 @@ declare class FunctionsClient {
      * ```
      */
     evaluateFunction(request: EvaluateFunctionRequest): Promise<EvaluateFunctionResponse>;
+    /**
+     * List all functions registered for the authenticated tenant.
+     *
+     * @returns The registered functions as typed signatures (name, arity, clause count) plus a total count.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * This is the discovery counterpart to {@link registerFunction} / {@link evaluateFunction}:
+     * it projects the tenant's slice of the function sub-lattice into a list of typed
+     * signatures without evaluating anything. The tenant is taken from the authenticated
+     * principal (never a body field).
+     *
+     * Returns response-only camelCase types; no value serialization is involved.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.functions.listFunctions();
+     * console.log(result.total); // number of registered functions
+     * for (const fn of result.functions) {
+     *   console.log(`${fn.name}/${fn.arity} (${fn.clausesCount} clauses)`);
+     * }
+     * ```
+     */
+    listFunctions(): Promise<ListFunctionsResponse>;
 }
 
 declare class WebhookActions<SecurityDataType = unknown> {
@@ -39662,6 +41311,15 @@ declare class Admin<SecurityDataType = unknown> {
      * @request POST:/api/v1/admin/clear-tenant/{tenant_id}
      */
     clearTenantData: (tenantId: string, params?: RequestParams) => Promise<HttpResponse<ClearTenantResponse$1, void>>;
+    /**
+     * @description Explicitly creates a tenant's inference state and sort hierarchy, optionally seeding initial sorts. Idempotent. No X-Tenant-Id header required.
+     *
+     * @tags admin
+     * @name CreateTenant
+     * @summary Provision a new tenant
+     * @request POST:/api/v1/admin/tenants
+     */
+    createTenant: (data: CreateTenantRequest$1, params?: RequestParams) => Promise<HttpResponse<CreateTenantResponse$1, any>>;
     /**
      * @description Returns all tenant IDs that have terms or ingestion sessions, with counts. No X-Tenant-Id header required. Works in both PostgreSQL and in-memory modes.
      *
@@ -39767,13 +41425,48 @@ interface ListTenantsResponse {
     /** All tenants that have data in the system. */
     tenants: TenantInfoDto[];
 }
+/**
+ * Request to provision a new tenant.
+ *
+ * @remarks
+ * Provisioning is explicit and idempotent: it materializes the tenant's
+ * inference state and per-tenant sort hierarchy up front, and optionally
+ * seeds initial top-level sorts. All fields are optional — omitted UUIDs
+ * are generated server-side.
+ */
+interface CreateTenantRequest {
+    /** Optional owner user UUID for the tenant's initial state. Generated when omitted. */
+    ownerUserId?: string | null;
+    /** Optional sort names to seed into the new tenant's hierarchy as top-level sorts. */
+    seedSorts?: string[];
+    /** Optional explicit tenant UUID. A fresh UUID is generated when omitted. */
+    tenantId?: string | null;
+}
+/**
+ * Response for the create-tenant operation.
+ *
+ * @remarks
+ * Reports whether the tenant was newly created (vs. already existed, since the
+ * operation is idempotent), how many seed sorts were inserted, and the
+ * provisioned tenant UUID.
+ */
+interface CreateTenantResponse {
+    /** `true` if the tenant was newly created; `false` if it already existed (idempotent). */
+    created: boolean;
+    /** Number of seed sorts successfully inserted into the tenant hierarchy. */
+    seededSorts: number;
+    /** The provisioned tenant UUID (echoes the request or the generated value). */
+    tenantId: string;
+}
 
 type admin_ClearTenantResponse = ClearTenantResponse;
+type admin_CreateTenantRequest = CreateTenantRequest;
+type admin_CreateTenantResponse = CreateTenantResponse;
 type admin_FactoryResetResponse = FactoryResetResponse;
 type admin_ListTenantsResponse = ListTenantsResponse;
 type admin_TenantInfoDto = TenantInfoDto;
 declare namespace admin {
-  export type { admin_ClearTenantResponse as ClearTenantResponse, admin_FactoryResetResponse as FactoryResetResponse, admin_ListTenantsResponse as ListTenantsResponse, admin_TenantInfoDto as TenantInfoDto };
+  export type { admin_ClearTenantResponse as ClearTenantResponse, admin_CreateTenantRequest as CreateTenantRequest, admin_CreateTenantResponse as CreateTenantResponse, admin_FactoryResetResponse as FactoryResetResponse, admin_ListTenantsResponse as ListTenantsResponse, admin_TenantInfoDto as TenantInfoDto };
 }
 
 /**
@@ -39853,6 +41546,31 @@ declare class AdminClient {
      * ```
      */
     listTenants(): Promise<ListTenantsResponse>;
+    /**
+     * Provision a new tenant.
+     *
+     * @param request - Tenant provisioning parameters. All fields are optional;
+     *   omitted UUIDs are generated server-side and seed sorts default to none.
+     * @returns Whether the tenant was newly created, how many seed sorts were
+     *   inserted, and the provisioned tenant UUID.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Explicitly creates a tenant's inference state and sort hierarchy, optionally
+     * seeding initial top-level sorts. Idempotent — provisioning an existing tenant
+     * returns `created: false`. No `X-Tenant-Id` header is required.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.admin.createTenant({
+     *   seedSorts: ['Person', 'Organization'],
+     * });
+     * console.log(result.tenantId);     // generated UUID
+     * console.log(result.created);      // true
+     * console.log(result.seededSorts);  // 2
+     * ```
+     */
+    createTenant(request: CreateTenantRequest): Promise<CreateTenantResponse>;
 }
 
 declare class ImageExtraction<SecurityDataType = unknown> {
@@ -40659,7 +42377,7 @@ interface VariableBounds {
  * };
  * ```
  */
-interface LinearConstraint {
+interface LinearConstraint$1 {
     /** Coefficients per variable. Missing variables have coefficient 0. */
     coefficients: LinearExpression;
     /** Comparison operator: <=, >=, or =. */
@@ -40706,7 +42424,7 @@ interface LinearProgramDefinition {
     /** Objective function to maximize or minimize. */
     objective: ObjectiveFunction;
     /** Linear constraints. */
-    constraints: LinearConstraint[];
+    constraints: LinearConstraint$1[];
     /** Variable bounds. Variables not listed are unbounded. */
     bounds?: Record<string, VariableBounds>;
 }
@@ -40815,7 +42533,7 @@ interface KBOptimizationConfig {
     /** Whether all variables must be non-negative (default: false). */
     nonNegative?: boolean;
     /** Additional explicit constraints to add beyond those discovered from the KB. */
-    additionalConstraints?: LinearConstraint[];
+    additionalConstraints?: LinearConstraint$1[];
 }
 /**
  * Result of a KB-driven optimization, including the discovered problem.
@@ -40835,7 +42553,6 @@ type optimize_KBOptimizationConfig = KBOptimizationConfig;
 type optimize_KBOptimizationResult = KBOptimizationResult;
 type optimize_KBResourceConstraint = KBResourceConstraint;
 type optimize_KBVariableSpec = KBVariableSpec;
-type optimize_LinearConstraint = LinearConstraint;
 type optimize_LinearExpression = LinearExpression;
 type optimize_LinearProgramDefinition = LinearProgramDefinition;
 type optimize_ObjectiveFunction = ObjectiveFunction;
@@ -40845,7 +42562,7 @@ type optimize_OptimizationResult = OptimizationResult;
 type optimize_SolveOptions = SolveOptions;
 type optimize_VariableBounds = VariableBounds;
 declare namespace optimize {
-  export type { optimize_ConstraintOperator as ConstraintOperator, optimize_InfeasibleResult as InfeasibleResult, optimize_KBOptimizationConfig as KBOptimizationConfig, optimize_KBOptimizationResult as KBOptimizationResult, optimize_KBResourceConstraint as KBResourceConstraint, optimize_KBVariableSpec as KBVariableSpec, optimize_LinearConstraint as LinearConstraint, optimize_LinearExpression as LinearExpression, optimize_LinearProgramDefinition as LinearProgramDefinition, optimize_ObjectiveFunction as ObjectiveFunction, optimize_OptimalResult as OptimalResult, optimize_OptimizationDirection as OptimizationDirection, optimize_OptimizationResult as OptimizationResult, optimize_SolveOptions as SolveOptions, optimize_VariableBounds as VariableBounds };
+  export type { optimize_ConstraintOperator as ConstraintOperator, optimize_InfeasibleResult as InfeasibleResult, optimize_KBOptimizationConfig as KBOptimizationConfig, optimize_KBOptimizationResult as KBOptimizationResult, optimize_KBResourceConstraint as KBResourceConstraint, optimize_KBVariableSpec as KBVariableSpec, LinearConstraint$1 as LinearConstraint, optimize_LinearExpression as LinearExpression, optimize_LinearProgramDefinition as LinearProgramDefinition, optimize_ObjectiveFunction as ObjectiveFunction, optimize_OptimalResult as OptimalResult, optimize_OptimizationDirection as OptimizationDirection, optimize_OptimizationResult as OptimizationResult, optimize_SolveOptions as SolveOptions, optimize_VariableBounds as VariableBounds };
 }
 
 /**
@@ -41952,6 +43669,17 @@ interface ConversationMessageResponse {
     intent: string;
     /** OSFQL that was executed (if any). */
     osfqlExecuted?: string | null;
+    /**
+     * True when {@link osfqlExecuted} is a constrained-regeneration *repair* of a query the
+     * certify-or-abstain gate first rejected as hallucinated. Lets the UI surface that the answer
+     * reflects a corrected query rather than the user's literal request.
+     */
+    repaired?: boolean;
+    /**
+     * The original, rejected OSFQL the LLM first proposed — present only when {@link repaired} is
+     * true. Pairs with {@link osfqlExecuted} so the UI can show the `original → executed` diff.
+     */
+    originalOsfql?: string | null;
     /** Query results (if OSFQL was a MATCH). Each entry maps variable names to bound values. */
     queryResults?: Record<string, OsfqlValue>[] | null;
     /** IDs of terms produced by the OSFQL execution. */
@@ -42014,6 +43742,53 @@ interface ConversationTurnsResponse {
     conversationId: string;
     turns: TurnDto[];
 }
+/**
+ * An entry in a session's focus stack — an entity ranked by ACT-R activation.
+ */
+interface FocusEntryDto {
+    /** Entity term ID (UUID string). */
+    termId: string;
+    /** Sort name of the entity. */
+    sortName: string;
+    /** Display label, if the entity has a name/label. */
+    label?: string | null;
+    /** Current ACT-R activation (salience). */
+    activation: number;
+    /** Rank (0 = most salient). */
+    rank: number;
+}
+/**
+ * A cross-turn coreference resolved within a session.
+ */
+interface ResolvedCoreferenceDto {
+    /** The referring-expression kind (from the LLM sensor). */
+    expressionType: string;
+    /** The resolved entity term ID, if any. */
+    resolvedTermId?: string | null;
+    /** The resolved entity's label, if any. */
+    resolvedLabel?: string | null;
+    /** Confidence (salience of the chosen candidate). */
+    confidence: number;
+    /** Whether the top two candidates were close (LLM tiebreaker advised). */
+    ambiguous: boolean;
+}
+/**
+ * Session memory snapshot for a conversation.
+ *
+ * @remarks
+ * Inspects the session's focus stack (entities ranked by ACT-R activation) and
+ * the cross-turn references resolved so far.
+ */
+interface SessionGraphDto {
+    /** Session ID (the conversation's UUID). */
+    sessionId: string;
+    /** Current turn number. */
+    currentTurn: number;
+    /** Entities ranked by current activation (most salient first). */
+    focusStack: FocusEntryDto[];
+    /** Cross-turn references resolved so far. */
+    resolvedCoreferences: ResolvedCoreferenceDto[];
+}
 
 type conversation_ClaimAnnotationDto = ClaimAnnotationDto;
 type conversation_ConversationMessageRequest = ConversationMessageRequest;
@@ -42021,12 +43796,15 @@ type conversation_ConversationMessageResponse = ConversationMessageResponse;
 type conversation_ConversationSummaryDto = ConversationSummaryDto;
 type conversation_ConversationTurnsResponse = ConversationTurnsResponse;
 type conversation_DerivationSummaryDto = DerivationSummaryDto;
+type conversation_FocusEntryDto = FocusEntryDto;
 type conversation_ListConversationsResponse = ListConversationsResponse;
 type conversation_ProofTraceNodeDto = ProofTraceNodeDto;
+type conversation_ResolvedCoreferenceDto = ResolvedCoreferenceDto;
+type conversation_SessionGraphDto = SessionGraphDto;
 type conversation_TurnDto = TurnDto;
 type conversation_UICustomizationDto = UICustomizationDto;
 declare namespace conversation {
-  export type { conversation_ClaimAnnotationDto as ClaimAnnotationDto, conversation_ConversationMessageRequest as ConversationMessageRequest, conversation_ConversationMessageResponse as ConversationMessageResponse, conversation_ConversationSummaryDto as ConversationSummaryDto, conversation_ConversationTurnsResponse as ConversationTurnsResponse, conversation_DerivationSummaryDto as DerivationSummaryDto, conversation_ListConversationsResponse as ListConversationsResponse, conversation_ProofTraceNodeDto as ProofTraceNodeDto, SourceExcerptDto$1 as SourceExcerptDto, conversation_TurnDto as TurnDto, conversation_UICustomizationDto as UICustomizationDto };
+  export type { conversation_ClaimAnnotationDto as ClaimAnnotationDto, conversation_ConversationMessageRequest as ConversationMessageRequest, conversation_ConversationMessageResponse as ConversationMessageResponse, conversation_ConversationSummaryDto as ConversationSummaryDto, conversation_ConversationTurnsResponse as ConversationTurnsResponse, conversation_DerivationSummaryDto as DerivationSummaryDto, conversation_FocusEntryDto as FocusEntryDto, conversation_ListConversationsResponse as ListConversationsResponse, conversation_ProofTraceNodeDto as ProofTraceNodeDto, conversation_ResolvedCoreferenceDto as ResolvedCoreferenceDto, conversation_SessionGraphDto as SessionGraphDto, SourceExcerptDto$1 as SourceExcerptDto, conversation_TurnDto as TurnDto, conversation_UICustomizationDto as UICustomizationDto };
 }
 
 /**
@@ -42115,6 +43893,28 @@ declare class ConversationClient {
      * ```
      */
     getTurns(conversationId: string): Promise<ConversationTurnsResponse>;
+    /**
+     * Get the session memory graph for a conversation.
+     *
+     * @param conversationId - The conversation ID.
+     * @returns The session's focus stack (entities ranked by ACT-R activation) and
+     *   the cross-turn coreferences resolved so far.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Inspects the session memory for a conversation: the focus stack (entities
+     * ranked by ACT-R activation) and the cross-turn references resolved so far.
+     *
+     * @example
+     * ```typescript
+     * const graph = await client.conversation.getSessionGraph('conv-uuid');
+     * console.log(`Turn ${graph.currentTurn}`);
+     * for (const entry of graph.focusStack) {
+     *   console.log(`#${entry.rank} ${entry.label ?? entry.termId} (${entry.activation})`);
+     * }
+     * ```
+     */
+    getSessionGraph(conversationId: string): Promise<SessionGraphDto>;
     /**
      * Delete a conversation and all its turns.
      *
@@ -43715,6 +45515,2184 @@ declare class OperationsClient {
     antiUnify(request: AntiUnifyRequest): Promise<AntiUnifyResponse>;
 }
 
+declare class Actions<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags actions
+     * @name ApplyAction
+     * @summary Apply a typed action transactionally.
+     * @request POST:/api/v1/actions/apply
+     * @secure
+     */
+    applyAction: (data: ApplyActionRequest$1, params?: RequestParams) => Promise<HttpResponse<ApplyActionResponse$1, ApplyActionResponse$1>>;
+}
+
+/**
+ * One scalar feature projected as an ontology property.
+ *
+ * @remarks
+ * Projected from a sort's appropriateness conditions. Wire shape (`PropertyDto`)
+ * uses camelCase field names (`apiName`, `dataType`).
+ */
+interface Property {
+    /** The feature name (Palantir property apiName). */
+    apiName: string;
+    /** The declared value-type hint, or `"string"` when unspecified. */
+    dataType: string;
+    /** Whether the feature is required by the sort's appropriateness conditions. */
+    required: boolean;
+}
+/**
+ * One action parameter projected from an action input spec.
+ *
+ * @remarks
+ * Wire shape (`ActionParameterDto`) uses the same field names; this type is
+ * shared with the {@link ActionType} projection.
+ */
+interface ActionParameter {
+    /** Parameter (input feature) name. */
+    name: string;
+    /** Whether the input is required. */
+    required: boolean;
+}
+/**
+ * One projected action type from the system action-spec catalog.
+ *
+ * @remarks
+ * Wire shape (`ActionTypeDto`) uses camelCase field names
+ * (`apiName`, `displayName`).
+ */
+interface ActionType {
+    /** Action sort name (Palantir action-type apiName). */
+    apiName: string;
+    /** Human-facing name (the action sort name). */
+    displayName: string;
+    /** Parameters — required inputs first, then optional. */
+    parameters: ActionParameter[];
+}
+/**
+ * Response for `GET /api/v1/ontology/action-types`.
+ *
+ * @remarks
+ * Shared with the Actions domain via `./actions.js`.
+ */
+interface ActionTypeListResponse {
+    /** The projected action types. */
+    actionTypes: ActionType[];
+    /** Number of action types returned. */
+    count: number;
+}
+/**
+ * One projected function type from the tenant's function store.
+ *
+ * @remarks
+ * Wire shape (`FunctionTypeDto`) uses camelCase field names
+ * (`apiName`, `displayName`, `clausesCount`).
+ */
+interface FunctionType {
+    /** Function name (Palantir function-type apiName). */
+    apiName: string;
+    /** Number of named-feature parameters (the function's arity). */
+    arity: number;
+    /** Number of defining clauses (homoiconic rules) backing the function. */
+    clausesCount: number;
+    /** Human-facing name (the function name). */
+    displayName: string;
+}
+/**
+ * Response for `GET /api/v1/ontology/function-types`.
+ */
+interface FunctionTypeListResponse {
+    /** Number of function types returned. */
+    count: number;
+    /** The projected function types, ordered by apiName. */
+    functionTypes: FunctionType[];
+}
+/**
+ * One projected interface type from a non-maximal (abstract) sort.
+ *
+ * @remarks
+ * Wire shape (`InterfaceTypeDto`) uses camelCase field names
+ * (`apiName`, `displayName`, `extendsInterfaceTypes`).
+ */
+interface InterfaceType {
+    /** Sort name (Palantir interface-type apiName). */
+    apiName: string;
+    /** Sort description, if any. */
+    description?: string | null;
+    /** Human-facing name (the sort name). */
+    displayName: string;
+    /** apiNames of supersorts that are themselves interfaces (extended interfaces). */
+    extendsInterfaceTypes: string[];
+    /** The appropriate scalar features that form the inherited contract. */
+    properties: Property[];
+}
+/**
+ * Response for `GET /api/v1/ontology/interface-types`.
+ */
+interface InterfaceTypeListResponse {
+    /** Number of interface types returned. */
+    count: number;
+    /** The projected interface types. */
+    interfaceTypes: InterfaceType[];
+}
+/**
+ * One projected link type from a referring feature.
+ *
+ * @remarks
+ * Wire shape (`LinkTypeDto`) uses camelCase field names
+ * (`apiName`, `displayName`, `linkedObjectTypeApiName`, `objectTypeApiName`).
+ */
+interface LinkType {
+    /** Qualified apiName `"<sort>.<feature>"`. */
+    apiName: string;
+    /** Cardinality — `ONE`, because OSF features are functional. */
+    cardinality: string;
+    /** The feature name. */
+    displayName: string;
+    /** The target object type (the feature's value sort). */
+    linkedObjectTypeApiName: string;
+    /** The source object type (the sort declaring the feature). */
+    objectTypeApiName: string;
+}
+/**
+ * Response for `GET /api/v1/ontology/link-types`.
+ */
+interface LinkTypeListResponse {
+    /** Number of link types returned. */
+    count: number;
+    /** The projected link types. */
+    linkTypes: LinkType[];
+}
+/**
+ * One projected object type from a tenant sort.
+ *
+ * @remarks
+ * Wire shape (`ObjectTypeDto`) uses camelCase field names
+ * (`apiName`, `displayName`, `implementsInterfaceTypes`, `primaryKey`).
+ */
+interface ObjectType {
+    /** Sort name (Palantir object-type apiName). */
+    apiName: string;
+    /** Sort description, if any. */
+    description?: string | null;
+    /** Human-facing name (the sort name). */
+    displayName: string;
+    /** apiNames of the supersorts this sort refines (the interfaces it implements). */
+    implementsInterfaceTypes: string[];
+    /** Primary key — Ψ-terms are identified by their `TermId`. */
+    primaryKey: string[];
+    /** Appropriate scalar features projected as properties. */
+    properties: Property[];
+    /** Lifecycle status — always `ACTIVE` for a live sort. */
+    status: string;
+}
+/**
+ * Response for `GET /api/v1/ontology/object-types`.
+ */
+interface ObjectTypeListResponse {
+    /** Number of object types returned. */
+    count: number;
+    /** The projected object types. */
+    objectTypes: ObjectType[];
+}
+
+type ontologyFacade_ActionParameter = ActionParameter;
+type ontologyFacade_ActionType = ActionType;
+type ontologyFacade_ActionTypeListResponse = ActionTypeListResponse;
+type ontologyFacade_FunctionType = FunctionType;
+type ontologyFacade_FunctionTypeListResponse = FunctionTypeListResponse;
+type ontologyFacade_InterfaceType = InterfaceType;
+type ontologyFacade_InterfaceTypeListResponse = InterfaceTypeListResponse;
+type ontologyFacade_LinkType = LinkType;
+type ontologyFacade_LinkTypeListResponse = LinkTypeListResponse;
+type ontologyFacade_ObjectType = ObjectType;
+type ontologyFacade_ObjectTypeListResponse = ObjectTypeListResponse;
+type ontologyFacade_Property = Property;
+declare namespace ontologyFacade {
+  export type { ontologyFacade_ActionParameter as ActionParameter, ontologyFacade_ActionType as ActionType, ontologyFacade_ActionTypeListResponse as ActionTypeListResponse, ontologyFacade_FunctionType as FunctionType, ontologyFacade_FunctionTypeListResponse as FunctionTypeListResponse, ontologyFacade_InterfaceType as InterfaceType, ontologyFacade_InterfaceTypeListResponse as InterfaceTypeListResponse, ontologyFacade_LinkType as LinkType, ontologyFacade_LinkTypeListResponse as LinkTypeListResponse, ontologyFacade_ObjectType as ObjectType, ontologyFacade_ObjectTypeListResponse as ObjectTypeListResponse, ontologyFacade_Property as Property };
+}
+
+/**
+ * One typed parameter of an action schema.
+ *
+ * @remarks
+ * Wire shape (`ParamSpecDto`) uses snake_case (`param_type`).
+ */
+interface ParamSpec {
+    /** Feature name. */
+    name: string;
+    /** Appropriateness type: `integer`, `real`, `string`, `boolean`, or `any`. */
+    paramType: string;
+    /** Whether the input must be bound for the action to be `Ready`. */
+    required?: boolean;
+}
+/**
+ * A validation rule over an action's parameters.
+ *
+ * @remarks
+ * Tagged discriminated union with `rule` as the discriminant. The wire shape
+ * (`ActionParamRuleDto`) is externally tagged by rule name
+ * (`non_empty_string`, `int_range`, `real_range`, `one_of`).
+ */
+type ActionParamRule = {
+    /** String parameter, when present, must be non-empty. */
+    rule: 'non_empty_string';
+    /** Parameter the rule applies to. */
+    param: string;
+} | {
+    /** Integer parameter, when present, in `[min, max]`. */
+    rule: 'int_range';
+    /** Parameter the rule applies to. */
+    param: string;
+    /** Inclusive lower bound. */
+    min: number;
+    /** Inclusive upper bound. */
+    max: number;
+} | {
+    /** Real parameter, when present, in `[min, max]`. */
+    rule: 'real_range';
+    /** Parameter the rule applies to. */
+    param: string;
+    /** Inclusive lower bound. */
+    min: number;
+    /** Inclusive upper bound. */
+    max: number;
+} | {
+    /** String parameter, when present, must be one of `allowed`. */
+    rule: 'one_of';
+    /** Parameter the rule applies to. */
+    param: string;
+    /** Permitted values. */
+    allowed: string[];
+};
+/**
+ * A declarative side-effect fired after the action applies.
+ *
+ * @remarks
+ * Wire shape (`ActionSideEffectDto`) uses the same field names.
+ */
+interface ActionSideEffect {
+    /** Notification title. */
+    title: string;
+    /** Notification body. */
+    body: string;
+    /** Delivery channel: `webhook`, `email`, `in_app`, or `browser_push`. */
+    channel: string;
+    /** Recipient/target (webhook URL or recipient address). */
+    target: string;
+}
+/**
+ * A typed, validated, RBAC-bound action schema.
+ *
+ * @remarks
+ * Wire shape (`ActionTypeDefDto`) uses snake_case for `required_roles` and
+ * `side_effects`.
+ */
+interface ActionTypeDef {
+    /** Action type name (the action sort). */
+    name: string;
+    /** Typed parameters. */
+    params?: ParamSpec[];
+    /** Roles required to apply this action (empty ⇒ unrestricted). */
+    requiredRoles?: string[];
+    /** Validation rules over parameters. */
+    rules?: ActionParamRule[];
+    /** Side-effects to dispatch once the action applies. */
+    sideEffects?: ActionSideEffect[];
+}
+/**
+ * A multi-term edit committed atomically when an action is `Ready`.
+ *
+ * @remarks
+ * Tagged discriminated union with `op` as the discriminant. The wire shape
+ * (`TermEditDto`) is externally tagged (`{ put: ... }` or `{ remove: ... }`).
+ * The `put` payload reuses the standard {@link CreateTermRequest} body.
+ */
+type TermEdit = {
+    /** Create or overwrite a term. */
+    op: 'put';
+    /** The term-creation body (tagged {@link ValueDto} features). */
+    term: CreateTermRequest;
+} | {
+    /** Remove an existing term by id. */
+    op: 'remove';
+    /** Term UUID to remove. */
+    termId: string;
+};
+/**
+ * Request to apply a typed action transactionally.
+ *
+ * @remarks
+ * Wire shape (`ApplyActionRequest`) uses snake_case (`caller_roles`).
+ * Bound inputs map feature names to arbitrary JSON values.
+ */
+interface ApplyActionRequest {
+    /** The action schema to apply. */
+    action: ActionTypeDef;
+    /** Bound input features (`feature → JSON value`). */
+    inputs?: Record<string, JsonValue$1>;
+    /** Roles held by the caller (checked against `action.requiredRoles`). */
+    callerRoles?: string[];
+    /** Multi-term edits to commit atomically when the action is `Ready`. */
+    edits?: TermEdit[];
+}
+/**
+ * Outcome of applying an action.
+ *
+ * @remarks
+ * Tagged discriminated union with `outcome` as the discriminant. The wire
+ * shape (`ApplyActionResponse`) uses the same discriminant with snake_case
+ * fields (`side_effects_dispatched`, `side_effects_failed`).
+ */
+type ApplyActionResponse = {
+    /** The action applied successfully. */
+    outcome: 'applied';
+    /** Number of side-effects delivered successfully. */
+    sideEffectsDispatched: number;
+    /** Number of side-effects whose delivery failed (apply still succeeded). */
+    sideEffectsFailed: number;
+} | {
+    /** The action is waiting for required inputs to be bound. */
+    outcome: 'suspended';
+    /** Names of the unbound required parameters. */
+    missing: string[];
+} | {
+    /** The action was rejected before applying. */
+    outcome: 'rejected';
+    /** Human-readable reason. */
+    reason: string;
+} | {
+    /** The action applied then rolled back. */
+    outcome: 'rolled_back';
+    /** Human-readable cause. */
+    reason: string;
+};
+
+type actions_ActionParamRule = ActionParamRule;
+type actions_ActionParameter = ActionParameter;
+type actions_ActionSideEffect = ActionSideEffect;
+type actions_ActionType = ActionType;
+type actions_ActionTypeDef = ActionTypeDef;
+type actions_ActionTypeListResponse = ActionTypeListResponse;
+type actions_ApplyActionRequest = ApplyActionRequest;
+type actions_ApplyActionResponse = ApplyActionResponse;
+type actions_ParamSpec = ParamSpec;
+type actions_TermEdit = TermEdit;
+declare namespace actions {
+  export type { actions_ActionParamRule as ActionParamRule, actions_ActionParameter as ActionParameter, actions_ActionSideEffect as ActionSideEffect, actions_ActionType as ActionType, actions_ActionTypeDef as ActionTypeDef, actions_ActionTypeListResponse as ActionTypeListResponse, actions_ApplyActionRequest as ApplyActionRequest, actions_ApplyActionResponse as ApplyActionResponse, actions_ParamSpec as ParamSpec, actions_TermEdit as TermEdit };
+}
+
+/**
+ * Resource client for applying typed actions.
+ *
+ * @remarks
+ * Provides access to the transactional action-application endpoint. An action
+ * is a typed, validated, RBAC-bound schema; applying it binds inputs, runs
+ * parameter rules, commits any atomic term edits, and dispatches declarative
+ * side-effects.
+ *
+ * Uses normalizers to convert between the SDK surface types (camelCase,
+ * `op`/`rule`/`outcome`-discriminated unions) and the wire format
+ * (snake_case, externally tagged unions) at the boundary.
+ */
+declare class ActionsClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: Actions);
+    /**
+     * Apply a typed action transactionally.
+     *
+     * @param request - The action schema, bound inputs, caller roles, and any
+     *   atomic term edits to commit when the action is `Ready`.
+     * @returns The outcome — `applied` (with side-effect dispatch counts),
+     *   `suspended` (with the unbound required parameters), `rejected`, or
+     *   `rolled_back` (each with a reason).
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Calls `POST /api/v1/actions/apply`. The request is converted to the wire
+     * format (snake_case fields such as `caller_roles`, externally tagged
+     * `rules`/`edits`) before sending; the response is normalized back to the
+     * `outcome`-discriminated SDK union.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.actions.applyAction({
+     *   action: {
+     *     name: 'approve_invoice',
+     *     params: [{ name: 'invoice_id', paramType: 'string', required: true }],
+     *     requiredRoles: ['finance'],
+     *   },
+     *   inputs: { invoice_id: 'INV-42' },
+     *   callerRoles: ['finance'],
+     * });
+     * if (result.outcome === 'applied') {
+     *   console.log(result.sideEffectsDispatched);
+     * } else if (result.outcome === 'suspended') {
+     *   console.log('missing', result.missing);
+     * }
+     * ```
+     */
+    applyAction(request: ApplyActionRequest): Promise<ApplyActionResponse>;
+}
+
+declare class ComplianceMarkings<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags compliance-markings
+     * @name Gate
+     * @summary `POST /api/v1/compliance/markings/gate` — may a reader holding `clearance` see data marked `marking`? Unknown level names yield 400.
+     * @request POST:/api/v1/compliance/markings/gate
+     * @secure
+     */
+    gate: (data: GateRequest$1, params?: RequestParams) => Promise<HttpResponse<GateResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags compliance-markings
+     * @name ListLevels
+     * @summary `GET /api/v1/compliance/markings/levels` — the classification lattice.
+     * @request GET:/api/v1/compliance/markings/levels
+     * @secure
+     */
+    listLevels: (params?: RequestParams) => Promise<HttpResponse<ListLevelsResponse$1, any>>;
+    /**
+     * No description
+     *
+     * @tags compliance-markings
+     * @name ReadableTerms
+     * @summary `GET /api/v1/compliance/markings/readable-terms?clearance=` — the tenant's terms a requester holding `clearance` may read. Withheld (residuated) terms are absent and only counted. `clearance` defaults to `Unclassified`.
+     * @request GET:/api/v1/compliance/markings/readable-terms
+     * @secure
+     */
+    readableTerms: (query?: {
+        /** Clearance level (defaults to Unclassified) */
+        clearance?: string;
+    }, params?: RequestParams) => Promise<HttpResponse<ReadableTermsResponse$1, void>>;
+}
+
+/**
+ * Request to evaluate a classification gate.
+ *
+ * @remarks
+ * Sent to `POST /api/v1/compliance/markings/gate`. Asks whether a reader
+ * holding `clearance` may see data marked `marking`. Both fields are
+ * classification level names from the lattice (e.g. `"Unclassified"`,
+ * `"Secret"`). Unknown level names yield a 400 error.
+ */
+interface GateRequest {
+    /** Classification level the reader holds. */
+    clearance: string;
+    /** Classification level the data is marked with. */
+    marking: string;
+}
+/**
+ * Result of a classification gate evaluation.
+ *
+ * @remarks
+ * Returned by `POST /api/v1/compliance/markings/gate`. `dominates` is the
+ * boolean verdict (does the clearance dominate the marking?); `decision` is
+ * the human-readable rendering of that verdict.
+ */
+interface GateResponse {
+    /** The clearance level that was evaluated. */
+    clearance: string;
+    /** Human-readable gate decision. */
+    decision: string;
+    /** Whether the clearance dominates the marking (the access verdict). */
+    dominates: boolean;
+    /** The marking level that was evaluated. */
+    marking: string;
+}
+/**
+ * A single classification level in the lattice.
+ *
+ * @remarks
+ * Returned as an element of {@link ListLevelsResponse}. `level` is the numeric
+ * rank within the lattice (0 = least sensitive); `name` is the level's label.
+ */
+interface ClassificationLevelDto {
+    /** Numeric rank of the level within the lattice (0 = least sensitive). */
+    level: number;
+    /** Level name (e.g. "Unclassified", "Secret"). */
+    name: string;
+}
+/**
+ * The classification lattice.
+ *
+ * @remarks
+ * Returned by `GET /api/v1/compliance/markings/levels`.
+ */
+interface ListLevelsResponse {
+    /** The classification levels, ordered by the lattice. */
+    levels: ClassificationLevelDto[];
+}
+/**
+ * A term the requester is cleared to read, with its marking.
+ *
+ * @remarks
+ * Returned as an element of {@link ReadableTermsResponse}.
+ */
+interface ReadableTermDto {
+    /** Term ID (UUID). */
+    id: string;
+    /** Classification level the term is marked with. */
+    marking: string;
+}
+/**
+ * The tenant's terms a requester holding a given clearance may read.
+ *
+ * @remarks
+ * Returned by `GET /api/v1/compliance/markings/readable-terms`. Withheld
+ * (residuated) terms are absent from `readable` and only reflected in
+ * `withheldCount`.
+ */
+interface ReadableTermsResponse {
+    /** The clearance level that was evaluated. */
+    clearance: string;
+    /** The readable terms with their markings. */
+    readable: ReadableTermDto[];
+    /** Number of terms the requester may read. */
+    readableCount: number;
+    /** Number of terms withheld (residuated) from the requester. */
+    withheldCount: number;
+}
+
+type complianceMarkings_ClassificationLevelDto = ClassificationLevelDto;
+type complianceMarkings_GateRequest = GateRequest;
+type complianceMarkings_GateResponse = GateResponse;
+type complianceMarkings_ListLevelsResponse = ListLevelsResponse;
+type complianceMarkings_ReadableTermDto = ReadableTermDto;
+type complianceMarkings_ReadableTermsResponse = ReadableTermsResponse;
+declare namespace complianceMarkings {
+  export type { complianceMarkings_ClassificationLevelDto as ClassificationLevelDto, complianceMarkings_GateRequest as GateRequest, complianceMarkings_GateResponse as GateResponse, complianceMarkings_ListLevelsResponse as ListLevelsResponse, complianceMarkings_ReadableTermDto as ReadableTermDto, complianceMarkings_ReadableTermsResponse as ReadableTermsResponse };
+}
+
+/**
+ * Resource client for classification marking (clearance gating) operations.
+ *
+ * @remarks
+ * Provides access to the compliance-markings endpoints, which evaluate the
+ * classification lattice: whether a reader holding a clearance may see data
+ * carrying a marking, the lattice of classification levels, and the tenant's
+ * terms a given clearance may read.
+ *
+ * This is distinct from the broader `compliance` resource.
+ *
+ * Uses normalizers to convert between camelCase (SDK surface) and
+ * snake_case (wire format) at the boundary.
+ */
+declare class ComplianceMarkingsClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: ComplianceMarkings);
+    /**
+     * Evaluate whether a clearance may see data carrying a marking.
+     *
+     * @param request - The clearance and marking level names to evaluate.
+     * @returns The gate decision, including the `dominates` verdict.
+     * @throws {ApiError} If a level name is unknown (400) or the request fails.
+     *
+     * @remarks
+     * Wire format is snake_case; both `clearance` and `marking` are
+     * classification level names from the lattice.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.complianceMarkings.gate({
+     *   clearance: 'Secret',
+     *   marking: 'Confidential',
+     * });
+     * console.log(result.dominates); // true
+     * console.log(result.decision);  // human-readable verdict
+     * ```
+     */
+    gate(request: GateRequest): Promise<GateResponse>;
+    /**
+     * List the classification lattice.
+     *
+     * @returns The classification levels, ordered by the lattice.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Wire format is snake_case; each level carries a numeric `level` rank and a
+     * `name`.
+     *
+     * @example
+     * ```typescript
+     * const { levels } = await client.complianceMarkings.listLevels();
+     * console.log(levels.map((l) => l.name)); // ["Unclassified", "Confidential", ...]
+     * ```
+     */
+    listLevels(): Promise<ListLevelsResponse>;
+    /**
+     * List the tenant's terms a requester holding a given clearance may read.
+     *
+     * @param clearance - Clearance level name. Defaults to `Unclassified` on the
+     *   backend when omitted.
+     * @returns The readable terms and the readable/withheld counts.
+     * @throws {ApiError} If the clearance name is unknown (400) or the request fails.
+     *
+     * @remarks
+     * Wire format is snake_case (`readable_count`, `withheld_count`). Withheld
+     * (residuated) terms are absent from `readable` and only reflected in
+     * `withheldCount`. The `clearance` argument is passed as the optional
+     * `clearance` query parameter.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.complianceMarkings.readableTerms('Secret');
+     * console.log(result.readableCount);
+     * console.log(result.withheldCount);
+     * console.log(result.readable.map((t) => t.id));
+     * ```
+     */
+    readableTerms(clearance?: string): Promise<ReadableTermsResponse>;
+}
+
+declare class Feasibility<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags feasibility
+     * @name AssumeFeasibilityVar
+     * @summary Assume a flat decision variable `true` in a feasibility session; returns the trichotomy delta and the updated classification — the per-assumption click path for sessions begun via [`begin_feasibility_session`].
+     * @request POST:/api/v1/feasibility/sessions/{session_id}/assumptions
+     * @secure
+     */
+    assumeFeasibilityVar: (sessionId: string, data: AssumptionRequest$1, params?: RequestParams) => Promise<HttpResponse<SchedulingDeltaResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags feasibility
+     * @name BeginFeasibilitySession
+     * @summary Begin a generic constraint-model feasibility session and return its id + the empty-assumptions trichotomy over `0..num_decision_vars`. The declarative-compiler interactive all-feasibilities surface — clicks assume flat variables via [`assume_feasibility_var`].
+     * @request POST:/api/v1/feasibility/sessions
+     * @secure
+     */
+    beginFeasibilitySession: (data: GenericModelRequest$1, params?: RequestParams) => Promise<HttpResponse<SchedulingSessionResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags feasibility
+     * @name EndFeasibilitySession
+     * @summary End (drop) a feasibility session.
+     * @request DELETE:/api/v1/feasibility/sessions/{session_id}
+     * @secure
+     */
+    endFeasibilitySession: (sessionId: string, params?: RequestParams) => Promise<HttpResponse<EndSchedulingResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags feasibility
+     * @name GetFeasibilitySession
+     * @summary Get a feasibility session's current classification.
+     * @request GET:/api/v1/feasibility/sessions/{session_id}
+     * @secure
+     */
+    getFeasibilitySession: (sessionId: string, params?: RequestParams) => Promise<HttpResponse<SchedulingSessionResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags feasibility
+     * @name RetractFeasibilityAssumption
+     * @summary Retract the most recent assumption, restoring the prior classification (no re-solve).
+     * @request DELETE:/api/v1/feasibility/sessions/{session_id}/assumptions/last
+     * @secure
+     */
+    retractFeasibilityAssumption: (sessionId: string, params?: RequestParams) => Promise<HttpResponse<SchedulingSessionResponse$1, void>>;
+}
+
+/**
+ * Comparison sense of a {@link LinearConstraint}.
+ *
+ * @remarks
+ * Wire values (snake_case): `"leq"`, `"geq"`, `"eq"`.
+ */
+type ConstraintSense = 'leq' | 'geq' | 'eq';
+/**
+ * Direction of an {@link Objective} function.
+ *
+ * @remarks
+ * Wire values (snake_case): `"minimize"`, `"maximize"`.
+ */
+type ObjectiveSense = 'minimize' | 'maximize';
+/**
+ * Kind of a {@link VariableSpec} decision variable. Defaults server-side to
+ * `"continuous"`.
+ *
+ * @remarks
+ * Wire values (snake_case): `"continuous"`, `"integer"`, `"binary"`.
+ */
+type VarKind = 'continuous' | 'integer' | 'binary';
+/**
+ * Backend-selection hint. `"auto"` (default) routes CP-SAT for fully discrete
+ * problems and HiGHS for any continuous variable.
+ *
+ * @remarks
+ * Wire values (snake_case): `"auto"`, `"prefer_cp"`, `"prefer_lp"`.
+ */
+type SolverHint = 'auto' | 'prefer_cp' | 'prefer_lp';
+/**
+ * Status reported by the solver for a solve or classification.
+ *
+ * @remarks
+ * Wire values (snake_case): `"optimal"`, `"feasible"`, `"infeasible"`,
+ * `"unbounded"`, `"unknown"`.
+ */
+type SolutionStatus = 'optimal' | 'feasible' | 'infeasible' | 'unbounded' | 'unknown';
+/**
+ * Per-variable classification — the ILP analog of flow-network edge
+ * classification (Dulmage-Mendelsohn).
+ *
+ * @remarks
+ * Wire values (snake_case): `"always_used"`, `"sometimes_used"`,
+ * `"never_used"`.
+ */
+type VariableClassification = 'always_used' | 'sometimes_used' | 'never_used';
+/**
+ * Relational operator used by the `compare` variant of a {@link BoolExpr}.
+ *
+ * @remarks
+ * Wire values (snake_case): `"equal"`, `"not_equal"`, `"less_than"`,
+ * `"less_than_or_equal"`, `"greater_than"`, `"greater_than_or_equal"`.
+ */
+type RelOp = 'equal' | 'not_equal' | 'less_than' | 'less_than_or_equal' | 'greater_than' | 'greater_than_or_equal';
+/**
+ * A single decision variable. Names must be unique within a problem and are
+ * echoed verbatim in the response `values` map.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ kind, lower_bound, name, upper_bound }`.
+ */
+interface VariableSpec {
+    /** Caller-chosen identifier. Must be unique. */
+    name: string;
+    /** Variable kind. Defaults to `"continuous"`. */
+    kind?: VarKind;
+    /** Lower bound. Use negative infinity for unbounded below. */
+    lowerBound?: number;
+    /** Upper bound. Use positive infinity for unbounded above. Ignored for `"binary"` (forced to 1). */
+    upperBound?: number;
+}
+/**
+ * A linear constraint `Σ coef_i · x_i (sense) rhs`. Variables not referenced in
+ * `coefficients` are treated as if their coefficient is zero.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ coefficients, name, rhs, sense }`. This is the
+ * solver/feasibility linear-constraint model; it is distinct from the
+ * `Optimize` namespace's `LinearConstraint`.
+ */
+interface LinearConstraint {
+    /** Variable-name → coefficient. */
+    coefficients: Record<string, number>;
+    /** Right-hand side. */
+    rhs: number;
+    /** Comparison sense. */
+    sense: ConstraintSense;
+    /** Optional caller-supplied label, returned in error reports. */
+    name?: string | null;
+}
+/**
+ * Objective function to optimize.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ coefficients, constant, sense }`.
+ */
+interface Objective {
+    /** Direction of the objective function. */
+    sense: ObjectiveSense;
+    /** Variable-name → coefficient. */
+    coefficients?: Record<string, number>;
+    /** Constant addend. */
+    constant?: number;
+}
+/**
+ * One term `coeff · var` of a {@link LinExpr}.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ coeff, var }`.
+ */
+interface LinTerm {
+    /** The integer coefficient. */
+    coeff: number;
+    /** The flat decision-variable index. */
+    var: number;
+}
+/**
+ * A linear expression `Σ coeff·var + constant` over flat decision-variable
+ * indices.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ constant, terms }`.
+ */
+interface LinExpr {
+    /** The constant addend. */
+    constant?: number;
+    /** The `coeff·var` terms. */
+    terms?: LinTerm[];
+}
+/**
+ * A literal over a flat decision-variable index, with a required polarity.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ value, var }`.
+ */
+interface Lit {
+    /** The required polarity (`true` ⇒ the var is set, `false` ⇒ unset). */
+    value: boolean;
+    /** The flat decision-variable index. */
+    var: number;
+}
+/**
+ * A boolean-valued expression over flat decision-variable indices.
+ *
+ * @remarks
+ * Tagged discriminated union keyed on `type`. Wire format (snake_case)
+ * mirrors this shape verbatim.
+ */
+type BoolExpr = {
+    type: 'lit';
+    value: boolean;
+    var: number;
+} | {
+    type: 'const';
+    value: boolean;
+} | {
+    type: 'not';
+    expr: BoolExpr;
+} | {
+    type: 'and';
+    exprs: BoolExpr[];
+} | {
+    type: 'or';
+    exprs: BoolExpr[];
+} | {
+    type: 'implies';
+    left: BoolExpr;
+    right: BoolExpr;
+} | {
+    type: 'iff';
+    left: BoolExpr;
+    right: BoolExpr;
+} | {
+    type: 'xor';
+    left: BoolExpr;
+    right: BoolExpr;
+} | {
+    type: 'compare';
+    left: LinExpr;
+    op: RelOp;
+    right: LinExpr;
+};
+/**
+ * A temporal rule enforced over a `regular` timeline.
+ *
+ * @remarks
+ * Tagged discriminated union keyed on `type`. Wire format (snake_case)
+ * mirrors this shape verbatim.
+ */
+type TemporalRule = {
+    type: 'no_consec';
+} | {
+    type: 'capacity';
+    max1ShiftPerDay: boolean;
+    maxDays: number;
+} | {
+    type: 'max_consecutive_nights';
+    k: number;
+};
+/**
+ * A typed constraint over the flat decision variables.
+ *
+ * @remarks
+ * Tagged discriminated union keyed on `type`. Wire format (snake_case)
+ * mirrors this shape verbatim; the `regular` variant's `rules` use
+ * {@link TemporalRule} and the `forbid`/`arithmetic` variants use {@link Lit} /
+ * {@link BoolExpr}.
+ */
+type TypedConstraint = {
+    type: 'global_cardinality';
+    vars: number[];
+    min: number;
+    max?: number | null;
+} | {
+    type: 'forbid';
+    lits: Lit[];
+} | {
+    type: 'pin';
+    var: number;
+} | {
+    type: 'regular';
+    vars: number[];
+    days: number;
+    shifts: number;
+    available: boolean[];
+    rules: TemporalRule[];
+} | {
+    type: 'all_different';
+    vars: number[];
+} | {
+    type: 'arithmetic';
+    expr: BoolExpr;
+};
+/**
+ * A single decision over which to explore alternatives. Each must have
+ * `alternativeCount ≥ 2`.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ alternative_count, description, variable_name }`.
+ */
+interface ChoicePoint {
+    /** Number of alternatives. */
+    alternativeCount: number;
+    /** Description of what this choice represents. */
+    description: string;
+    /** Optional variable name for arithmetic constraints. */
+    variableName?: string | null;
+}
+/**
+ * A generic constraint-model request used to begin a feasibility session.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ choice_points, constraints, objective }`. Owned here
+ * as part of the shared cluster; consumed by the Feasibility domain.
+ */
+interface GenericModelRequest {
+    /** The decisions to explore, in order. Each must have `alternativeCount ≥ 2`. */
+    choicePoints: ChoicePoint[];
+    /** The typed constraints over the flat decision variables. */
+    constraints?: TypedConstraint[];
+    /**
+     * Optional linear objective to **maximize** (`Σ weight·var` over the true
+     * decision variables), as `(var, weight)` terms. Empty/omitted ⇒ pure-feasibility
+     * mode (the trichotomy over all feasible completions). Non-empty ⇒ optimize mode:
+     * the trichotomy is taken over the **maximum-weight** completions and the responses
+     * carry `totalScore` (the optimum). A var absent from the list has weight `0`;
+     * duplicate vars sum.
+     */
+    objective?: LinTerm[];
+}
+/**
+ * Request body for `POST /api/v1/solver/solve`.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ constraints, gap_tolerance, hint, objective,
+ * time_limit_ms, variables }`.
+ */
+interface SolveProblemRequest {
+    /** The decision variables of the problem. */
+    variables: VariableSpec[];
+    /** Linear constraints over the variables. */
+    constraints?: LinearConstraint[];
+    /** Objective function; omit for a pure feasibility solve. */
+    objective?: Objective | null;
+    /** Backend-selection hint. */
+    hint?: SolverHint;
+    /** Relative MIP gap tolerance (e.g. `0.01` for 1%). `0.0` means solve to proven optimum. */
+    gapTolerance?: number | null;
+    /** Wall-clock limit per solve, in milliseconds. Defaults server-side to 30000. */
+    timeLimitMs?: number | null;
+}
+/**
+ * Response body for `POST /api/v1/solver/solve`.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ message, objective_value, solve_time_ms, solver,
+ * status, values }`.
+ */
+interface SolveProblemResponse {
+    /** Status reported by the solver. */
+    status: SolutionStatus;
+    /** `"cp_sat"` or `"highs"`. */
+    solver: string;
+    /** Variable-name → optimal value. Empty for infeasible/unbounded. */
+    values: Record<string, number>;
+    /** Objective value at the optimum, when an objective was supplied. */
+    objectiveValue?: number | null;
+    /** Wall-clock solve time inside the solver service, in milliseconds. */
+    solveTimeMs: number;
+    /** Optional diagnostic message (e.g. when status is `"unknown"`). */
+    message?: string | null;
+}
+/**
+ * Request body for `POST /api/v1/solver/classify`. Same fields as
+ * {@link SolveProblemRequest} plus an optional list of variable names whose
+ * classification is requested; omitting it classifies every binary variable.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ constraints, gap_tolerance, hint, objective,
+ * time_limit_ms, variables, variables_of_interest }`.
+ */
+interface ClassifyProblemRequest {
+    /** The decision variables of the problem. */
+    variables: VariableSpec[];
+    /** Linear constraints over the variables. */
+    constraints?: LinearConstraint[];
+    /** Objective function; omit for a pure feasibility classification. */
+    objective?: Objective | null;
+    /** Backend-selection hint. */
+    hint?: SolverHint;
+    /** Relative MIP gap tolerance. */
+    gapTolerance?: number | null;
+    /** Wall-clock limit per solve, in milliseconds. */
+    timeLimitMs?: number | null;
+    /** Variables to classify. Omit (or send empty) to classify every binary variable. */
+    variablesOfInterest?: string[] | null;
+}
+/**
+ * Response body for `POST /api/v1/solver/classify`.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ baseline_values, classifications, message,
+ * solve_time_ms, solver, status }`.
+ */
+interface ClassifyProblemResponse {
+    /** Status reported by the solver. */
+    status: SolutionStatus;
+    /** `"cp_sat"` or `"highs"`. */
+    solver: string;
+    /** Variable-name → classification. Empty when the baseline is infeasible. */
+    classifications: Record<string, VariableClassification>;
+    /** Variable-name → baseline solve value. A concrete witness alongside the classification. */
+    baselineValues: Record<string, number>;
+    /** Wall-clock solve time inside the solver service, in milliseconds. */
+    solveTimeMs: number;
+    /** Optional diagnostic message. */
+    message?: string | null;
+}
+/**
+ * Response body for `GET /api/v1/solver/health`.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ status }`.
+ */
+interface SolverHealthResponse {
+    /** Liveness marker — `"ok"` when the upstream solver service is reachable. */
+    status: string;
+}
+
+type solver_BoolExpr = BoolExpr;
+type solver_ChoicePoint = ChoicePoint;
+type solver_ClassifyProblemRequest = ClassifyProblemRequest;
+type solver_ClassifyProblemResponse = ClassifyProblemResponse;
+type solver_ConstraintSense = ConstraintSense;
+type solver_GenericModelRequest = GenericModelRequest;
+type solver_LinExpr = LinExpr;
+type solver_LinTerm = LinTerm;
+type solver_LinearConstraint = LinearConstraint;
+type solver_Lit = Lit;
+type solver_Objective = Objective;
+type solver_ObjectiveSense = ObjectiveSense;
+type solver_RelOp = RelOp;
+type solver_SolutionStatus = SolutionStatus;
+type solver_SolveProblemRequest = SolveProblemRequest;
+type solver_SolveProblemResponse = SolveProblemResponse;
+type solver_SolverHealthResponse = SolverHealthResponse;
+type solver_SolverHint = SolverHint;
+type solver_TemporalRule = TemporalRule;
+type solver_TypedConstraint = TypedConstraint;
+type solver_VarKind = VarKind;
+type solver_VariableClassification = VariableClassification;
+type solver_VariableSpec = VariableSpec;
+declare namespace solver {
+  export type { solver_BoolExpr as BoolExpr, solver_ChoicePoint as ChoicePoint, solver_ClassifyProblemRequest as ClassifyProblemRequest, solver_ClassifyProblemResponse as ClassifyProblemResponse, solver_ConstraintSense as ConstraintSense, solver_GenericModelRequest as GenericModelRequest, solver_LinExpr as LinExpr, solver_LinTerm as LinTerm, solver_LinearConstraint as LinearConstraint, solver_Lit as Lit, solver_Objective as Objective, solver_ObjectiveSense as ObjectiveSense, solver_RelOp as RelOp, solver_SolutionStatus as SolutionStatus, solver_SolveProblemRequest as SolveProblemRequest, solver_SolveProblemResponse as SolveProblemResponse, solver_SolverHealthResponse as SolverHealthResponse, solver_SolverHint as SolverHint, solver_TemporalRule as TemporalRule, solver_TypedConstraint as TypedConstraint, solver_VarKind as VarKind, solver_VariableClassification as VariableClassification, solver_VariableSpec as VariableSpec };
+}
+
+/**
+ * Request to assume a single flat decision variable `true` within a session.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ var }`.
+ */
+interface AssumptionRequest {
+    /** The flat decision-variable index to assume `true`. */
+    var: number;
+}
+/**
+ * The per-cell trichotomy classification of a feasibility session.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ confirmed_false, confirmed_true, sometimes }`.
+ * Cells are referenced by flat decision-variable index.
+ */
+interface Classification {
+    /** Cells in every valid completion — forced/highlighted. */
+    confirmedTrue: number[];
+    /** Cells in no valid completion — gray these out. */
+    confirmedFalse: number[];
+    /** Cells that are a free choice. */
+    sometimes: number[];
+}
+/**
+ * Response carrying a session id and its current classification.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ classification, session_id, total_score }`.
+ */
+interface SchedulingSessionResponse {
+    /** Opaque session id. */
+    sessionId: string;
+    /** The current per-cell trichotomy. */
+    classification: Classification;
+    /**
+     * In optimize mode (the request carried an `objective`), the optimum
+     * `Σ weight·var` over the optimal completions at the current pins; absent for
+     * pure-feasibility models.
+     */
+    totalScore?: number | null;
+}
+/**
+ * Response from assuming a variable: the full classification after the pin plus
+ * the cells whose status changed.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ classification, newly_confirmed_false,
+ * newly_confirmed_true, total_score }`.
+ */
+interface SchedulingDeltaResponse {
+    /** The full classification after the pin. */
+    classification: Classification;
+    /** Cells that became `confirmedTrue` on this pin (incl. the pinned cell). */
+    newlyConfirmedTrue: number[];
+    /** Cells that became `confirmedFalse` on this pin. */
+    newlyConfirmedFalse: number[];
+    /**
+     * In optimize mode, the optimum `Σ weight·var` after this assumption; absent
+     * for pure-feasibility models. The optimum can drop as pins shrink the optimal
+     * set, so always trust `classification` for repaint — the optimize delta can
+     * also un-confirm cells.
+     */
+    totalScore?: number | null;
+}
+/**
+ * Response from ending a feasibility session.
+ *
+ * @remarks
+ * Wire shape (snake_case): `{ ended }`.
+ */
+interface EndSchedulingResponse {
+    /** Whether a live session was removed. */
+    ended: boolean;
+}
+
+type feasibility_AssumptionRequest = AssumptionRequest;
+type feasibility_Classification = Classification;
+type feasibility_EndSchedulingResponse = EndSchedulingResponse;
+type feasibility_SchedulingDeltaResponse = SchedulingDeltaResponse;
+type feasibility_SchedulingSessionResponse = SchedulingSessionResponse;
+declare namespace feasibility {
+  export type { feasibility_AssumptionRequest as AssumptionRequest, feasibility_Classification as Classification, feasibility_EndSchedulingResponse as EndSchedulingResponse, feasibility_SchedulingDeltaResponse as SchedulingDeltaResponse, feasibility_SchedulingSessionResponse as SchedulingSessionResponse };
+}
+
+/**
+ * Resource client for interactive constraint-model feasibility sessions.
+ *
+ * @remarks
+ * A session is begun from a generic constraint model
+ * ({@link GenericModelRequest}) and returns its id plus the empty-assumptions
+ * trichotomy over the flat decision variables. Each subsequent assumption pins
+ * a variable `true` and returns the resulting classification delta; the most
+ * recent assumption can be retracted without a re-solve.
+ *
+ * Uses normalizers to convert between camelCase (SDK surface) and snake_case
+ * (wire format) at the boundary.
+ */
+declare class FeasibilityClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: Feasibility);
+    /**
+     * Begin a generic constraint-model feasibility session.
+     *
+     * @param request - The constraint model: choice points and typed constraints
+     *   over the flat decision variables.
+     * @returns The new session id and the empty-assumptions trichotomy.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Wraps `POST /api/v1/feasibility/sessions` (snake_case wire format).
+     *
+     * @example
+     * ```typescript
+     * const session = await client.feasibility.beginFeasibilitySession({
+     *   choicePoints: [{ alternativeCount: 2, description: 'shift A or B' }],
+     *   constraints: [{ type: 'all_different', vars: [0, 1] }],
+     * });
+     * console.log(session.sessionId);
+     * console.log(session.classification.sometimes);
+     * ```
+     */
+    beginFeasibilitySession(request: GenericModelRequest): Promise<SchedulingSessionResponse>;
+    /**
+     * Assume a flat decision variable `true` within a session.
+     *
+     * @param sessionId - The session id returned by
+     *   {@link FeasibilityClient.beginFeasibilitySession}.
+     * @param request - The flat decision-variable index to pin `true`.
+     * @returns The trichotomy delta and the updated classification.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Wraps `POST /api/v1/feasibility/sessions/{session_id}/assumptions`
+     * (snake_case wire format).
+     *
+     * @example
+     * ```typescript
+     * const delta = await client.feasibility.assumeFeasibilityVar(sessionId, { var: 0 });
+     * console.log(delta.newlyConfirmedTrue);
+     * console.log(delta.newlyConfirmedFalse);
+     * ```
+     */
+    assumeFeasibilityVar(sessionId: string, request: AssumptionRequest): Promise<SchedulingDeltaResponse>;
+    /**
+     * Retract the most recent assumption, restoring the prior classification.
+     *
+     * @param sessionId - The session id.
+     * @returns The restored classification (no re-solve is performed).
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Wraps `DELETE /api/v1/feasibility/sessions/{session_id}/assumptions/last`
+     * (snake_case wire format).
+     *
+     * @example
+     * ```typescript
+     * const session = await client.feasibility.retractFeasibilityAssumption(sessionId);
+     * console.log(session.classification.sometimes);
+     * ```
+     */
+    retractFeasibilityAssumption(sessionId: string): Promise<SchedulingSessionResponse>;
+    /**
+     * Get a session's current classification.
+     *
+     * @param sessionId - The session id.
+     * @returns The session id and its current trichotomy.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Wraps `GET /api/v1/feasibility/sessions/{session_id}` (snake_case wire
+     * format).
+     *
+     * @example
+     * ```typescript
+     * const session = await client.feasibility.getFeasibilitySession(sessionId);
+     * console.log(session.classification.confirmedTrue);
+     * ```
+     */
+    getFeasibilitySession(sessionId: string): Promise<SchedulingSessionResponse>;
+    /**
+     * End (drop) a feasibility session.
+     *
+     * @param sessionId - The session id.
+     * @returns Whether a live session was removed.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Wraps `DELETE /api/v1/feasibility/sessions/{session_id}` (snake_case wire
+     * format).
+     *
+     * @example
+     * ```typescript
+     * const result = await client.feasibility.endFeasibilitySession(sessionId);
+     * console.log(result.ended); // true
+     * ```
+     */
+    endFeasibilitySession(sessionId: string): Promise<EndSchedulingResponse>;
+}
+
+declare class Solver<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @description Returns per-variable always_used / sometimes_used / never_used classifications.  Used by the rostering page to render the same trichotomy view-model as the flow-network scheduling page.
+     *
+     * @tags solver
+     * @name ClassifyProblem
+     * @summary Forward a classify request to the external solver service.
+     * @request POST:/api/v1/solver/classify
+     * @secure
+     */
+    classifyProblem: (data: ClassifyProblemRequest$1, params?: RequestParams) => Promise<HttpResponse<ClassifyProblemResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags solver
+     * @name SolveProblem
+     * @summary Forward a solve request to the external solver service.
+     * @request POST:/api/v1/solver/solve
+     * @secure
+     */
+    solveProblem: (data: SolveProblemRequest$1, params?: RequestParams) => Promise<HttpResponse<SolveProblemResponse$1, void>>;
+    /**
+     * No description
+     *
+     * @tags solver
+     * @name SolverHealth
+     * @summary Liveness probe — forwards to the solver service's `/health` endpoint so callers can confirm the upstream is reachable from inside the backend's network.
+     * @request GET:/api/v1/solver/health
+     */
+    solverHealth: (params?: RequestParams) => Promise<HttpResponse<SolverHealthResponse$1, void>>;
+}
+
+/**
+ * Resource client for the external constraint-solver service.
+ *
+ * @remarks
+ * Forwards linear / mixed-integer constraint problems to the upstream solver
+ * (CP-SAT or HiGHS, selected via {@link SolveProblemRequest.hint}) and returns
+ * either an optimal solution or a per-variable always/sometimes/never-used
+ * classification.
+ *
+ * Uses normalizers to convert between camelCase (SDK surface) and snake_case
+ * (wire format) at the boundary.
+ */
+declare class SolverClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: Solver);
+    /**
+     * Classify each variable as always-used, sometimes-used, or never-used
+     * across the feasible (or optimal) region of a constraint problem.
+     *
+     * @param request - The problem: variables, constraints, optional objective,
+     *   solver hint, and the variables of interest to classify.
+     * @returns The per-variable classifications plus a baseline witness solution.
+     * @throws {ApiError} If the request fails or the solver service is unreachable.
+     *
+     * @remarks
+     * Wraps `POST /api/v1/solver/classify` (snake_case wire format). Omit
+     * `variablesOfInterest` to classify every binary variable.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.solver.classifyProblem({
+     *   variables: [
+     *     { name: 'x', kind: 'binary' },
+     *     { name: 'y', kind: 'binary' },
+     *   ],
+     *   constraints: [
+     *     { coefficients: { x: 1, y: 1 }, sense: 'leq', rhs: 1 },
+     *   ],
+     * });
+     * console.log(result.status);          // "optimal"
+     * console.log(result.classifications); // { x: "sometimes_used", y: "sometimes_used" }
+     * ```
+     */
+    classifyProblem(request: ClassifyProblemRequest): Promise<ClassifyProblemResponse>;
+    /**
+     * Solve a linear / mixed-integer constraint problem.
+     *
+     * @param request - The problem: variables, constraints, optional objective,
+     *   solver hint, gap tolerance, and time limit.
+     * @returns The solution status, solver used, optimal variable values, and
+     *   objective value (when an objective was supplied).
+     * @throws {ApiError} If the request fails or the solver service is unreachable.
+     *
+     * @remarks
+     * Wraps `POST /api/v1/solver/solve` (snake_case wire format). Omit
+     * `objective` for a pure feasibility solve.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.solver.solveProblem({
+     *   variables: [
+     *     { name: 'chairs', kind: 'integer', lowerBound: 0 },
+     *     { name: 'tables', kind: 'integer', lowerBound: 0 },
+     *   ],
+     *   constraints: [
+     *     { coefficients: { chairs: 1, tables: 3 }, sense: 'leq', rhs: 12 },
+     *   ],
+     *   objective: { sense: 'maximize', coefficients: { chairs: 3, tables: 5 } },
+     * });
+     * console.log(result.status);         // "optimal"
+     * console.log(result.objectiveValue); // 20
+     * ```
+     */
+    solveProblem(request: SolveProblemRequest): Promise<SolveProblemResponse>;
+    /**
+     * Liveness probe for the upstream solver service.
+     *
+     * @returns A status marker — `status` is `"ok"` when the upstream solver
+     *   service responded to its `/health` endpoint.
+     * @throws {ApiError} If the request fails or the solver service is unreachable.
+     *
+     * @remarks
+     * Wraps `GET /api/v1/solver/health` (snake_case wire format).
+     *
+     * @example
+     * ```typescript
+     * const health = await client.solver.solverHealth();
+     * console.log(health.status); // "ok"
+     * ```
+     */
+    solverHealth(): Promise<SolverHealthResponse>;
+}
+
+declare class OntologyAlignment<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags ontology_alignment
+     * @name AlignOntology
+     * @summary Align a domain ontology to the upper ontology (BFO-2020).
+     * @request POST:/api/v1/ontology/align
+     * @secure
+     */
+    alignOntology: (data: AlignOntologyRequest$1, params?: RequestParams) => Promise<HttpResponse<AlignOntologyResponse$1, void>>;
+}
+
+/**
+ * Request to align a domain ontology against one or more upper ontologies.
+ *
+ * @remarks
+ * Sent to `POST /api/v1/ontology/align`. Wire format is snake_case
+ * (`domain_owl`).
+ */
+interface AlignOntologyRequest {
+    /** Domain ontology to align, as OWL/RDF-XML. */
+    domainOwl: string;
+    /** Upper ontologies to align against. Defaults to `["BFO"]` when empty. */
+    targets?: string[];
+}
+/**
+ * A confirmed SKOS correspondence from a domain class to an upper-ontology class.
+ */
+interface AlignmentMatchDto {
+    /** Domain sort name. */
+    domainSort: string;
+    /** SKOS relation: `exactMatch` / `broadMatch` / `narrowMatch` / `closeMatch`. */
+    matchType: string;
+    /** Upper-ontology class CURIE (e.g. the BFO IRI's CURIE form). */
+    targetCurie: string;
+    /** Upper-ontology class label. */
+    targetLabel: string;
+}
+/**
+ * Two upper-ontology candidates a domain class cannot map to simultaneously
+ * (their lattice meet is ⊥ — e.g. disjoint BFO branches).
+ */
+interface AlignmentConflictDto {
+    /** Domain sort name whose candidates conflict. */
+    domainSort: string;
+    /** The kept (higher-scored) candidate CURIE. */
+    targetA: string;
+    /** The rejected, incompatible candidate CURIE. */
+    targetB: string;
+}
+/**
+ * A SKOS external-ontology alignment attached to a sort.
+ *
+ * @remarks
+ * Populated by the upper-ontology aligner so each correspondence is a live,
+ * queryable property of the sort rather than a separate static export.
+ */
+interface ExternalMatchDto {
+    /** SKOS mapping relation: `exactMatch` | `closeMatch` | `broadMatch` | `narrowMatch`. */
+    matchType: string;
+    /** CURIE of the aligned external concept (e.g. `obo:BFO_0000023`). */
+    ontologyId: string;
+    /** How the match was discovered: `grounding` | `manual` | `import` | `inferred`. */
+    source: string;
+}
+/**
+ * Response from an ontology-alignment run.
+ */
+interface AlignOntologyResponse {
+    /** Surfaced ⊥-conflicts among proposed candidates. */
+    conflicts: AlignmentConflictDto[];
+    /** Number of domain sorts considered. */
+    domainSorts: number;
+    /** The MAPPING artifact as Turtle (`skos:*` + `kortexya:confidence`). */
+    mappingTtl: string;
+    /** Confirmed SKOS correspondences. */
+    matches: AlignmentMatchDto[];
+    /** Number of upper-ontology target sorts indexed. */
+    targetSorts: number;
+}
+
+type ontologyAlignment_AlignOntologyRequest = AlignOntologyRequest;
+type ontologyAlignment_AlignOntologyResponse = AlignOntologyResponse;
+type ontologyAlignment_AlignmentConflictDto = AlignmentConflictDto;
+type ontologyAlignment_AlignmentMatchDto = AlignmentMatchDto;
+type ontologyAlignment_ExternalMatchDto = ExternalMatchDto;
+declare namespace ontologyAlignment {
+  export type { ontologyAlignment_AlignOntologyRequest as AlignOntologyRequest, ontologyAlignment_AlignOntologyResponse as AlignOntologyResponse, ontologyAlignment_AlignmentConflictDto as AlignmentConflictDto, ontologyAlignment_AlignmentMatchDto as AlignmentMatchDto, ontologyAlignment_ExternalMatchDto as ExternalMatchDto };
+}
+
+/**
+ * Resource client for ontology-alignment operations.
+ *
+ * @remarks
+ * Provides access to the upper-ontology aligner, which maps a domain
+ * ontology (OWL/RDF-XML) onto an upper ontology such as BFO-2020 and
+ * surfaces SKOS correspondences and ⊥-conflicts.
+ *
+ * Uses normalizers to convert between camelCase (SDK surface) and
+ * snake_case (wire format) at the boundary.
+ */
+declare class OntologyAlignmentClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: OntologyAlignment);
+    /**
+     * Align a domain ontology to an upper ontology (e.g. BFO-2020).
+     *
+     * @param request - The domain ontology (OWL/RDF-XML) and optional target
+     *   upper ontologies to align against.
+     * @returns The alignment result: confirmed SKOS matches, surfaced conflicts,
+     *   the MAPPING artifact as Turtle, and the counts of domain/target sorts.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `POST /api/v1/ontology/align`. The request and response use the
+     * snake_case wire format (`domain_owl`, `mapping_ttl`, `domain_sorts`,
+     * `target_sorts`); this client normalizes to/from camelCase at the boundary.
+     * When `targets` is empty or omitted, the backend defaults to `["BFO"]`.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ontologyAlignment.alignOntology({
+     *   domainOwl: '<rdf:RDF>...</rdf:RDF>',
+     *   targets: ['BFO'],
+     * });
+     * console.log(result.matches.length);   // confirmed correspondences
+     * console.log(result.conflicts.length); // ⊥-conflicts to review
+     * console.log(result.mappingTtl);       // Turtle MAPPING artifact
+     * ```
+     */
+    alignOntology(request: AlignOntologyRequest): Promise<AlignOntologyResponse>;
+}
+
+declare class OntologyFacade<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags ontology_facade
+     * @name ListActionTypes
+     * @summary List action types — projected from the system action-spec catalog.
+     * @request GET:/api/v1/ontology/action-types
+     * @secure
+     */
+    listActionTypes: (params?: RequestParams) => Promise<HttpResponse<ActionTypeListResponse$1, any>>;
+    /**
+     * No description
+     *
+     * @tags ontology_facade
+     * @name ListFunctionTypes
+     * @summary List function types — projected from the tenant's function store.
+     * @request GET:/api/v1/ontology/function-types
+     * @secure
+     */
+    listFunctionTypes: (params?: RequestParams) => Promise<HttpResponse<FunctionTypeListResponse$1, any>>;
+    /**
+     * No description
+     *
+     * @tags ontology_facade
+     * @name ListInterfaceTypes
+     * @summary List interface types — projected from non-maximal (abstract) sorts.
+     * @request GET:/api/v1/ontology/interface-types
+     * @secure
+     */
+    listInterfaceTypes: (params?: RequestParams) => Promise<HttpResponse<InterfaceTypeListResponse$1, any>>;
+    /**
+     * No description
+     *
+     * @tags ontology_facade
+     * @name ListLinkTypes
+     * @summary List link types — projected from referring features across the tenant's sorts.
+     * @request GET:/api/v1/ontology/link-types
+     * @secure
+     */
+    listLinkTypes: (params?: RequestParams) => Promise<HttpResponse<LinkTypeListResponse$1, any>>;
+    /**
+     * No description
+     *
+     * @tags ontology_facade
+     * @name ListObjectTypes
+     * @summary List object types — projected from the tenant's sorts.
+     * @request GET:/api/v1/ontology/object-types
+     * @secure
+     */
+    listObjectTypes: (params?: RequestParams) => Promise<HttpResponse<ObjectTypeListResponse$1, any>>;
+}
+
+/**
+ * Resource client for the ontology facade.
+ *
+ * @remarks
+ * Provides read-only projections of the tenant's ontology in a Palantir-style
+ * view — object types (sorts), interface types (abstract sorts), link types
+ * (referring features), function types (the function store), and action types
+ * (the system action-spec catalog).
+ *
+ * Uses normalizers to convert between the SDK surface types and the wire
+ * format at the boundary.
+ */
+declare class OntologyFacadeClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: OntologyFacade);
+    /**
+     * List action types projected from the system action-spec catalog.
+     *
+     * @returns The projected action types with a count.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Calls `GET /api/v1/ontology/action-types`. Wire fields are camelCase
+     * (`actionTypes`, `apiName`, `displayName`).
+     *
+     * @example
+     * ```typescript
+     * const { actionTypes, count } = await client.ontologyFacade.listActionTypes();
+     * console.log(count, actionTypes[0]?.apiName);
+     * ```
+     */
+    listActionTypes(): Promise<ActionTypeListResponse>;
+    /**
+     * List function types projected from the tenant's function store.
+     *
+     * @returns The projected function types with a count, ordered by apiName.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Calls `GET /api/v1/ontology/function-types`. Wire fields are camelCase
+     * (`functionTypes`, `apiName`, `clausesCount`).
+     *
+     * @example
+     * ```typescript
+     * const { functionTypes } = await client.ontologyFacade.listFunctionTypes();
+     * console.log(functionTypes.map((f) => f.apiName));
+     * ```
+     */
+    listFunctionTypes(): Promise<FunctionTypeListResponse>;
+    /**
+     * List interface types projected from non-maximal (abstract) sorts.
+     *
+     * @returns The projected interface types with a count.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Calls `GET /api/v1/ontology/interface-types`. Wire fields are camelCase
+     * (`interfaceTypes`, `apiName`, `extendsInterfaceTypes`).
+     *
+     * @example
+     * ```typescript
+     * const { interfaceTypes } = await client.ontologyFacade.listInterfaceTypes();
+     * console.log(interfaceTypes[0]?.extendsInterfaceTypes);
+     * ```
+     */
+    listInterfaceTypes(): Promise<InterfaceTypeListResponse>;
+    /**
+     * List link types projected from referring features across the tenant's sorts.
+     *
+     * @returns The projected link types with a count.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Calls `GET /api/v1/ontology/link-types`. Wire fields are camelCase
+     * (`linkTypes`, `apiName`, `linkedObjectTypeApiName`, `objectTypeApiName`).
+     *
+     * @example
+     * ```typescript
+     * const { linkTypes } = await client.ontologyFacade.listLinkTypes();
+     * console.log(linkTypes[0]?.objectTypeApiName);
+     * ```
+     */
+    listLinkTypes(): Promise<LinkTypeListResponse>;
+    /**
+     * List object types projected from the tenant's sorts.
+     *
+     * @returns The projected object types with a count.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Calls `GET /api/v1/ontology/object-types`. Wire fields are camelCase
+     * (`objectTypes`, `apiName`, `implementsInterfaceTypes`, `primaryKey`).
+     *
+     * @example
+     * ```typescript
+     * const { objectTypes } = await client.ontologyFacade.listObjectTypes();
+     * console.log(objectTypes.map((o) => o.apiName));
+     * ```
+     */
+    listObjectTypes(): Promise<ObjectTypeListResponse>;
+}
+
+declare class OntologyBridge<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @description Creates a mapping between an OSF sort and a SQL table, enabling OSFQL-to-SQL transpilation for that sort.
+     *
+     * @tags ontology_bridge
+     * @name BindSort
+     * @summary Bind a sort to a SQL table with explicit column mappings.
+     * @request POST:/api/v1/ontology/bindings
+     * @secure
+     */
+    bindSort: (data: BindSortRequest$1, params?: RequestParams) => Promise<HttpResponse<BindSortResponse$1, void>>;
+    /**
+     * @description Produces query tools, write tools, and inference tools from the current sort hierarchy and SQL bindings, along with a system prompt suitable for grounding an LLM.
+     *
+     * @tags ontology_bridge
+     * @name GroundedSchema
+     * @summary Generate ontology-grounded NL tool schemas.
+     * @request GET:/api/v1/ontology/grounded-schema
+     * @secure
+     */
+    groundedSchema: (params?: RequestParams) => Promise<HttpResponse<GroundedSchemaResponse$1, any>>;
+    /**
+     * @description The "Palantir refugee on-ramp": parses a Foundry-shape ontology export and registers its object/interface types as sorts and link types as referring features (via the same path as OWL import). Returns the created sorts plus a report of what mapped and what needs review (unsupported property types, action types).
+     *
+     * @tags ontology_bridge
+     * @name ImportFoundry
+     * @summary Import a Foundry ontology export into the sort hierarchy (Q1.8).
+     * @request POST:/api/v1/ontology/import-foundry
+     * @secure
+     */
+    importFoundry: (data: ImportFoundryRequest$1, params?: RequestParams) => Promise<HttpResponse<ImportFoundryResponse$1, void>>;
+    /**
+     * @description Parses the OWL XML, converts classes to sorts, and registers them. Returns the created sort names and discovered relations.
+     *
+     * @tags ontology_bridge
+     * @name ImportOwl
+     * @summary Import an OWL/RDF ontology into the sort hierarchy.
+     * @request POST:/api/v1/ontology/import
+     * @secure
+     */
+    importOwl: (data: ImportOwlRequest$1, params?: RequestParams) => Promise<HttpResponse<ImportOwlResponse$1, void>>;
+    /**
+     * @description Returns all active bindings between OSF sorts and SQL tables.
+     *
+     * @tags ontology_bridge
+     * @name ListBindings
+     * @summary List all sort-table bindings.
+     * @request GET:/api/v1/ontology/bindings
+     * @secure
+     */
+    listBindings: (params?: RequestParams) => Promise<HttpResponse<ListBindingsResponse$1, any>>;
+    /**
+     * @description Parses the OSFQL query, compiles it, and transpiles the first `ScanBySort` operation to SQL using the current sort-table bindings.
+     *
+     * @tags ontology_bridge
+     * @name Transpile
+     * @summary Transpile an OSFQL query to SQL.
+     * @request POST:/api/v1/ontology/transpile
+     * @secure
+     */
+    transpile: (data: TranspileRequest$1, params?: RequestParams) => Promise<HttpResponse<TranspileResponse$1, void>>;
+    /**
+     * @description Unbinds a sort from its SQL table, disabling SQL transpilation for it.
+     *
+     * @tags ontology_bridge
+     * @name UnbindSort
+     * @summary Remove a sort-table binding.
+     * @request DELETE:/api/v1/ontology/bindings/{sort_name}
+     * @secure
+     */
+    unbindSort: (sortName: string, params?: RequestParams) => Promise<HttpResponse<void, void>>;
+}
+
+/**
+ * A column mapping between a SQL column and an OSF feature.
+ *
+ * @remarks
+ * Used in {@link BindSortRequest}. Wire format is snake_case (`sql_type`).
+ */
+interface ColumnMappingDto {
+    /** SQL column name. */
+    column: string;
+    /** OSF feature name. */
+    feature: string;
+    /** Whether the column is nullable. */
+    nullable?: boolean;
+    /**
+     * SQL type (e.g., "VARCHAR(255)", "INTEGER"). Omit or leave empty to have
+     * the server introspect the real type from the registered source's live
+     * schema (falls back to TEXT if the source isn't connected).
+     */
+    sqlType?: string;
+}
+/**
+ * Request to bind an OSF sort to a SQL table with explicit column mappings.
+ *
+ * @remarks
+ * Sent to `POST /api/v1/ontology/bindings`. Wire format is snake_case
+ * (`key_columns`, `sort_name`, `source_id`, `table_name`).
+ */
+interface BindSortRequest {
+    /** Column mappings: feature name to column spec. */
+    columns: ColumnMappingDto[];
+    /** Primary key column names. */
+    keyColumns?: string[];
+    /** Sort name to bind. */
+    sortName: string;
+    /** External source identifier. */
+    sourceId: string;
+    /** SQL table name. */
+    tableName: string;
+}
+/**
+ * Response from binding a sort to a SQL table.
+ */
+interface BindSortResponse {
+    /** Whether the binding was successful. */
+    bound: boolean;
+    /** Sort name that was bound. */
+    sortName: string;
+    /** SQL table the sort is bound to. */
+    tableName: string;
+}
+/**
+ * Summary of a single active sort-table binding.
+ */
+interface BindingSummaryDto {
+    /** Number of bound features/columns. */
+    featureCount: number;
+    /** Primary key column names. */
+    keyColumns: string[];
+    /** Sort ID (UUID string). */
+    sortId: string;
+    /** External source identifier. */
+    sourceId: string;
+    /** SQL table name. */
+    tableName: string;
+}
+/**
+ * Response listing all active sort-table bindings.
+ */
+interface ListBindingsResponse {
+    /** Active sort-table bindings. */
+    bindings: BindingSummaryDto[];
+}
+/**
+ * Response from generating ontology-grounded NL tool schemas.
+ */
+interface GroundedSchemaResponse {
+    /** Number of inference tools. */
+    inferenceTools: number;
+    /** Human-readable ontology summary. */
+    ontologySummary: string;
+    /** Number of query tools generated. */
+    queryTools: number;
+    /** System prompt for LLM grounding. */
+    systemPrompt: string;
+    /** Number of write tools generated. */
+    writeTools: number;
+}
+/**
+ * Request to import a Foundry ontology export into the sort hierarchy.
+ *
+ * @remarks
+ * Sent to `POST /api/v1/ontology/import-foundry`. Wire format is snake_case
+ * (`foundry_json`).
+ */
+interface ImportFoundryRequest {
+    /** The Foundry ontology export, as JSON. */
+    foundryJson: string;
+}
+/**
+ * An item imported with a caveat or skipped — needs human review.
+ */
+interface FoundryReviewItemDto {
+    /** What kind of item (`property_type`, `action_type`). */
+    kind: string;
+    /** The item's apiName. */
+    name: string;
+    /** Why it needs review. */
+    reason: string;
+}
+/**
+ * Response from a Foundry import: what was created plus a mapped/review-needed report.
+ */
+interface ImportFoundryResponse {
+    /** Interface types mapped to (super) sorts. */
+    mappedInterfaceTypes: number;
+    /** Link types mapped to referring features. */
+    mappedLinks: number;
+    /** Object types mapped to sorts. */
+    mappedObjectTypes: number;
+    /** Properties mapped to features. */
+    mappedProperties: number;
+    /** Number of relations discovered from link types. */
+    relationsDiscovered: number;
+    /** Items imported with a caveat or skipped — need human review. */
+    reviewNeeded: FoundryReviewItemDto[];
+    /** Names of sorts created (object + interface types). */
+    sortsCreated: string[];
+}
+/**
+ * Request to import an OWL/RDF ontology into the sort hierarchy.
+ *
+ * @remarks
+ * Sent to `POST /api/v1/ontology/import`. Wire format is snake_case (`rdf_xml`).
+ */
+interface ImportOwlRequest {
+    /** OWL/RDF XML content to import. */
+    rdfXml: string;
+}
+/**
+ * Response from an OWL ontology import.
+ */
+interface ImportOwlResponse {
+    /** Names of reified sorts created (many-to-many with attributes). */
+    reifiedSortsCreated: string[];
+    /** Number of relations discovered from OWL object properties. */
+    relationsDiscovered: number;
+    /** Names of sorts created from OWL classes. */
+    sortsCreated: string[];
+}
+/**
+ * Request to transpile an OSFQL query to SQL.
+ *
+ * @remarks
+ * Sent to `POST /api/v1/ontology/transpile`. Wire format is snake_case
+ * (the `osfql` and `dialect` fields are already lowercase).
+ */
+interface TranspileRequest {
+    /** SQL dialect: "postgres", "mysql", or "sqlite". */
+    dialect?: string;
+    /** OSFQL query to transpile. */
+    osfql: string;
+}
+/**
+ * Response from OSFQL-to-SQL transpilation.
+ */
+interface TranspileResponse {
+    /** Whether the entire plan is SQL-transpilable. */
+    fullyTranspilable: boolean;
+    /** Number of parameters in the generated SQL. */
+    paramCount: number;
+    /** Source ID the query targets. */
+    sourceId?: string | null;
+    /** Generated SQL query. */
+    sql: string;
+}
+
+type ontologyBridge_BindSortRequest = BindSortRequest;
+type ontologyBridge_BindSortResponse = BindSortResponse;
+type ontologyBridge_BindingSummaryDto = BindingSummaryDto;
+type ontologyBridge_ColumnMappingDto = ColumnMappingDto;
+type ontologyBridge_FoundryReviewItemDto = FoundryReviewItemDto;
+type ontologyBridge_GroundedSchemaResponse = GroundedSchemaResponse;
+type ontologyBridge_ImportFoundryRequest = ImportFoundryRequest;
+type ontologyBridge_ImportFoundryResponse = ImportFoundryResponse;
+type ontologyBridge_ImportOwlRequest = ImportOwlRequest;
+type ontologyBridge_ImportOwlResponse = ImportOwlResponse;
+type ontologyBridge_ListBindingsResponse = ListBindingsResponse;
+type ontologyBridge_TranspileRequest = TranspileRequest;
+type ontologyBridge_TranspileResponse = TranspileResponse;
+declare namespace ontologyBridge {
+  export type { ontologyBridge_BindSortRequest as BindSortRequest, ontologyBridge_BindSortResponse as BindSortResponse, ontologyBridge_BindingSummaryDto as BindingSummaryDto, ontologyBridge_ColumnMappingDto as ColumnMappingDto, ontologyBridge_FoundryReviewItemDto as FoundryReviewItemDto, ontologyBridge_GroundedSchemaResponse as GroundedSchemaResponse, ontologyBridge_ImportFoundryRequest as ImportFoundryRequest, ontologyBridge_ImportFoundryResponse as ImportFoundryResponse, ontologyBridge_ImportOwlRequest as ImportOwlRequest, ontologyBridge_ImportOwlResponse as ImportOwlResponse, ontologyBridge_ListBindingsResponse as ListBindingsResponse, ontologyBridge_TranspileRequest as TranspileRequest, ontologyBridge_TranspileResponse as TranspileResponse };
+}
+
+/**
+ * Resource client for ontology-bridge operations.
+ *
+ * @remarks
+ * Bridges the OSF sort hierarchy to external systems: binds sorts to SQL
+ * tables, transpiles OSFQL queries to SQL, imports OWL/RDF and Foundry
+ * ontologies into the sort hierarchy, and generates ontology-grounded NL
+ * tool schemas for LLM grounding.
+ *
+ * Uses normalizers to convert between camelCase (SDK surface) and
+ * snake_case (wire format) at the boundary.
+ */
+declare class OntologyBridgeClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: OntologyBridge);
+    /**
+     * Bind a sort to a SQL table with explicit column mappings.
+     *
+     * @param request - The sort name, target table, source identifier, key
+     *   columns, and per-feature column mappings.
+     * @returns Whether the binding succeeded plus the bound sort and table names.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `POST /api/v1/ontology/bindings`. Request/response use the
+     * snake_case wire format (`sort_name`, `table_name`, `source_id`,
+     * `key_columns`, `sql_type`); this client normalizes at the boundary.
+     * Creates a mapping enabling OSFQL-to-SQL transpilation for that sort.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ontologyBridge.bindSort({
+     *   sortName: 'person',
+     *   tableName: 'people',
+     *   sourceId: 'warehouse',
+     *   keyColumns: ['id'],
+     *   columns: [
+     *     { feature: 'name', column: 'full_name' },
+     *     { feature: 'age', column: 'age', sqlType: 'INTEGER' },
+     *   ],
+     * });
+     * console.log(result.bound); // true
+     * ```
+     */
+    bindSort(request: BindSortRequest): Promise<BindSortResponse>;
+    /**
+     * Generate ontology-grounded NL tool schemas.
+     *
+     * @returns Counts of query/write/inference tools, a human-readable ontology
+     *   summary, and a system prompt suitable for grounding an LLM.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `GET /api/v1/ontology/grounded-schema`. The response uses the
+     * snake_case wire format (`query_tools`, `write_tools`, `inference_tools`,
+     * `ontology_summary`, `system_prompt`); this client normalizes at the
+     * boundary. Tools are derived from the current sort hierarchy and SQL
+     * bindings.
+     *
+     * @example
+     * ```typescript
+     * const schema = await client.ontologyBridge.groundedSchema();
+     * console.log(schema.queryTools);   // number of query tools
+     * console.log(schema.systemPrompt); // LLM grounding prompt
+     * ```
+     */
+    groundedSchema(): Promise<GroundedSchemaResponse>;
+    /**
+     * Import a Foundry ontology export into the sort hierarchy.
+     *
+     * @param request - The Foundry ontology export, as a JSON string.
+     * @returns The counts of mapped object/interface types, properties, links,
+     *   and discovered relations, the names of created sorts, and a list of
+     *   items needing human review.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `POST /api/v1/ontology/import-foundry`. Request/response use the
+     * snake_case wire format (`foundry_json`, `mapped_object_types`,
+     * `mapped_interface_types`, `mapped_properties`, `mapped_links`,
+     * `relations_discovered`, `review_needed`, `sorts_created`); this client
+     * normalizes at the boundary. Parses a Foundry-shape export and registers its
+     * object/interface types as sorts and link types as referring features.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ontologyBridge.importFoundry({
+     *   foundryJson: foundryExportString,
+     * });
+     * console.log(result.sortsCreated);  // names of created sorts
+     * console.log(result.reviewNeeded);  // items needing review
+     * ```
+     */
+    importFoundry(request: ImportFoundryRequest): Promise<ImportFoundryResponse>;
+    /**
+     * Import an OWL/RDF ontology into the sort hierarchy.
+     *
+     * @param request - The OWL/RDF-XML content to import.
+     * @returns The names of created sorts, the names of reified sorts created,
+     *   and the number of relations discovered from OWL object properties.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `POST /api/v1/ontology/import`. Request/response use the snake_case
+     * wire format (`rdf_xml`, `sorts_created`, `reified_sorts_created`,
+     * `relations_discovered`); this client normalizes at the boundary. Parses the
+     * OWL XML, converts classes to sorts, and registers them.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ontologyBridge.importOwl({
+     *   rdfXml: '<rdf:RDF>...</rdf:RDF>',
+     * });
+     * console.log(result.sortsCreated);        // names of sorts created
+     * console.log(result.relationsDiscovered); // count of relations
+     * ```
+     */
+    importOwl(request: ImportOwlRequest): Promise<ImportOwlResponse>;
+    /**
+     * List all sort-table bindings.
+     *
+     * @returns All active bindings between OSF sorts and SQL tables.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `GET /api/v1/ontology/bindings`. The response uses the snake_case
+     * wire format (`feature_count`, `key_columns`, `sort_id`, `source_id`,
+     * `table_name`); this client normalizes at the boundary.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ontologyBridge.listBindings();
+     * for (const binding of result.bindings) {
+     *   console.log(binding.sortId, '->', binding.tableName);
+     * }
+     * ```
+     */
+    listBindings(): Promise<ListBindingsResponse>;
+    /**
+     * Transpile an OSFQL query to SQL.
+     *
+     * @param request - The OSFQL query and optional SQL dialect ("postgres",
+     *   "mysql", or "sqlite").
+     * @returns The generated SQL, whether the entire plan is SQL-transpilable,
+     *   the parameter count, and the source ID the query targets.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `POST /api/v1/ontology/transpile`. The response uses the snake_case
+     * wire format (`fully_transpilable`, `param_count`, `source_id`); this client
+     * normalizes at the boundary. Parses and compiles the OSFQL query, then
+     * transpiles the first `ScanBySort` operation to SQL using the current
+     * sort-table bindings.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ontologyBridge.transpile({
+     *   osfql: 'MATCH person(name: ?N);',
+     *   dialect: 'postgres',
+     * });
+     * console.log(result.sql);               // generated SQL
+     * console.log(result.fullyTranspilable); // true if fully SQL-backed
+     * ```
+     */
+    transpile(request: TranspileRequest): Promise<TranspileResponse>;
+    /**
+     * Remove a sort-table binding.
+     *
+     * @param sortName - The name of the sort to unbind.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Sent to `DELETE /api/v1/ontology/bindings/{sort_name}`. Unbinds a sort from
+     * its SQL table, disabling SQL transpilation for it. Returns no body.
+     *
+     * @example
+     * ```typescript
+     * await client.ontologyBridge.unbindSort('person');
+     * ```
+     */
+    unbindSort(sortName: string): Promise<void>;
+}
+
 /** Core knowledge base operations — types, records, rules, functions, constraints, and queries. */
 interface CoreGroup {
     readonly types: SortsClient;
@@ -43908,6 +47886,20 @@ declare class ReasoningLayerClient {
     readonly compliance: ComplianceClient;
     /** Low-level term-graph operations (anti-unification / LGG). */
     readonly operations: OperationsClient;
+    /** Typed-action engine — apply a typed action transactionally with multi-term edits. */
+    readonly actions: ActionsClient;
+    /** Classification/clearance gating over the marking lattice (compliance markings). */
+    readonly complianceMarkings: ComplianceMarkingsClient;
+    /** Interactive constraint-model feasibility sessions (assume/retract with trichotomy classification). */
+    readonly feasibility: FeasibilityClient;
+    /** External constraint solver — classify and solve generic optimization problems. */
+    readonly solver: SolverClient;
+    /** Ontology alignment to the upper ontology (BFO-2020). */
+    readonly ontologyAlignment: OntologyAlignmentClient;
+    /** Ontology facade — project object/link/interface/function/action types from the sort hierarchy. */
+    readonly ontologyFacade: OntologyFacadeClient;
+    /** Ontology bridge — OSF↔SQL bindings, OWL/Foundry import, OSFQL→SQL transpilation. */
+    readonly ontologyBridge: OntologyBridgeClient;
     private _core?;
     private _ai?;
     private _reasoning?;
@@ -44934,7 +48926,7 @@ declare const LP: {
      * // { coefficients: { chairs: 1, tables: 3 }, op: '<=', rhs: 12, label: 'wood' }
      * ```
      */
-    readonly constraint: (coefficients: LinearExpression, op: ConstraintOperator, rhs: number, label?: string) => LinearConstraint;
+    readonly constraint: (coefficients: LinearExpression, op: ConstraintOperator, rhs: number, label?: string) => LinearConstraint$1;
     /**
      * Create non-negativity bounds (>= 0) for the given variables.
      *
@@ -45382,4 +49374,4 @@ declare function toUntaggedFeatures(features: PlainFeatureMap): Record<string, F
  */
 declare function toTermInputDto(input: PsiTermInput | TermInputDto): TermInputDto;
 
-export { ANY_ROLE, actionReviews as ActionReviews, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, type ArithmeticOp, type AuthConfig, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClassifyEdgesInput, type ClassifyEdgesVars, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, type ComparisonOp, compliance as Compliance, type ConstrainedPlainVar, Constraint, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type DataGroup, discovery as Discovery, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, type FeatureInputValueDto, type FeatureValueDto, Flow, type FlowProblem as FlowBuilderProblem, type FlowEdgeInput, type FlowEdgeOptions, flowNetworks as FlowNetworks, type FlowNode, type FlowProblemInputBase, ForbiddenError, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, LP, type ListConversationsResponse, type LubRequest, type LubResponse, type MaxFlowInput, type MaxFlowVars, type MinCostMaxFlowInput, type MinCostMaxFlowVars, type MinCutInput, type MinCutVars, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, type Operand, operations as Operations, optimize as Optimize, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, preferences as Preferences, proofEngine as ProofEngine, type PsiTermDto, type PsiTermInput, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, reviews as Reviews, row as Row, SDK_VERSION, scenarios as Scenarios, scheduling as Scheduling, type SearchPapersRequest, type SearchPapersResponse, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, statistical as Statistical, synthetic as Synthetic, type SystemGroup, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, terms as Terms, TimeoutError, type TurnDto, type UpdateTermRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, type VerifyClaimRequest, type VerifyClaimResponse, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };
+export { ANY_ROLE, actionReviews as ActionReviews, actions as Actions, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, type ArithmeticOp, type AuthConfig, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClassifyEdgesInput, type ClassifyEdgesVars, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, type ComparisonOp, compliance as Compliance, complianceMarkings as ComplianceMarkings, type ConstrainedPlainVar, Constraint, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type DataGroup, discovery as Discovery, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, feasibility as Feasibility, type FeatureInputValueDto, type FeatureValueDto, Flow, type FlowProblem as FlowBuilderProblem, type FlowEdgeInput, type FlowEdgeOptions, flowNetworks as FlowNetworks, type FlowNode, type FlowProblemInputBase, ForbiddenError, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, LP, type ListConversationsResponse, type LubRequest, type LubResponse, type MaxFlowInput, type MaxFlowVars, type MinCostMaxFlowInput, type MinCostMaxFlowVars, type MinCutInput, type MinCutVars, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, ontologyAlignment as OntologyAlignment, ontologyBridge as OntologyBridge, ontologyFacade as OntologyFacade, type Operand, operations as Operations, optimize as Optimize, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, preferences as Preferences, proofEngine as ProofEngine, type PsiTermDto, type PsiTermInput, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, reviews as Reviews, row as Row, SDK_VERSION, scenarios as Scenarios, scheduling as Scheduling, type SearchPapersRequest, type SearchPapersResponse, solver as Solver, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, statistical as Statistical, synthetic as Synthetic, type SystemGroup, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, terms as Terms, TimeoutError, type TurnDto, type UpdateTermRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, type VerifyClaimRequest, type VerifyClaimResponse, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };