@kortexya/reasoninglayer 0.16.0 → 0.18.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 = "0.16.0";
+declare const SDK_VERSION = "0.18.0";
 /**
  * Configuration for the Reasoning Layer client.
  *
@@ -674,6 +674,31 @@ interface AgentGoalDto$1 {
      */
     term_id: string;
 }
+/** A single agent's static properties. */
+interface AgentInput {
+    /** Caller-chosen identifier.  Must be unique within the request. */
+    id: string;
+    /**
+     * Maximum number of slots this agent may be assigned across the
+     * full horizon.
+     * @format int32
+     * @min 0
+     */
+    max_assignments: number;
+    /**
+     * When present, the agent may only be assigned to this shift
+     * index (all other shifts become unavailable).
+     * @min 0
+     */
+    restricted_to_shift?: number | null;
+    /**
+     * Role tags this agent carries (e.g. `"icu"`, `"senior"`).  Used
+     * to satisfy per-role minimum-demand constraints.
+     */
+    roles?: string[];
+    /** Day indices on which the agent is unavailable for any shift. */
+    unavailable_days?: number[];
+}
 /** Agent state DTO. */
 interface AgentStateDto$1 {
     /**
@@ -1012,6 +1037,27 @@ type AssignValueDto$1 = {
     term_id: string;
     type: "term_ref";
 };
+/** One entry per `(agent_id, day, shift)` in the input grid. */
+interface AssignmentDto {
+    /** Echoes the `id` from [`AgentInput`]. */
+    agent_id: string;
+    /** @min 0 */
+    day: number;
+    /** @min 0 */
+    shift: number;
+    /**
+     * Per-cell feasibility classification.
+     *
+     * Every cell in the input grid is classified as exactly one of these.
+     */
+    status: AssignmentStatusDto;
+}
+/**
+ * Per-cell feasibility classification.
+ *
+ * Every cell in the input grid is classified as exactly one of these.
+ */
+type AssignmentStatusDto = "confirmed_true" | "confirmed_false" | "free";
 /** Attention target DTO. */
 type AttentionTargetDto$1 = {
     /** @format uuid */
@@ -11427,6 +11473,14 @@ interface PendingReviewEntityDto {
     /** Original text span that was extracted */
     source_text?: string | null;
 }
+/** A pre-assigned `(agent, day, shift)` triple. */
+interface PinInput {
+    agent_id: string;
+    /** @min 0 */
+    day: number;
+    /** @min 0 */
+    shift: number;
+}
 /** Pipeline quality statistics from validation gates and feedback loop */
 interface PipelineQualityStatsDto$1 {
     /**
@@ -13613,6 +13667,49 @@ interface ScenarioSummaryDto$1 {
      */
     sorts_created: number;
 }
+/**
+ * A scheduling feasibility request.
+ *
+ * Agents are identified by opaque caller-chosen string IDs so the
+ * response can be joined back to whatever identity the caller
+ * maintains (e.g. employee numbers, user IDs, UUIDs).
+ */
+interface SchedulingFeasibilityRequest$1 {
+    /** All agents that may be assigned to slots. */
+    agents: AgentInput[];
+    /**
+     * Number of days in the scheduling horizon.  Valid day indices
+     * are `0..days`.
+     * @min 0
+     */
+    days: number;
+    /** Per-slot demand.  At most one entry per `(day, shift)` pair. */
+    demands: ShiftDemandInput[];
+    /**
+     * Pre-assigned `(agent_id, day, shift)` triples the caller has
+     * fixed; the engine treats each as confirmed-true and reduces
+     * the remaining demand accordingly.
+     */
+    pins?: PinInput[];
+    /**
+     * Number of shifts per day.  Valid shift indices are
+     * `0..shifts_per_day`.
+     * @min 0
+     */
+    shifts_per_day: number;
+}
+/** Response to [`SchedulingFeasibilityRequest`]. */
+interface SchedulingFeasibilityResponse$1 {
+    /**
+     * Empty when `status` is `infeasible`; otherwise contains one
+     * entry per `(agent, day, shift)` triple in the input grid.
+     */
+    assignments: AssignmentDto[];
+    /** Top-level request status. */
+    status: SchedulingStatusDto;
+}
+/** Top-level request status. */
+type SchedulingStatusDto = "feasible" | "infeasible";
 /** Request to search communities */
 interface SearchCommunitiesRequest$1 {
     /**
@@ -13904,6 +14001,25 @@ interface SetSortSimilarityResponse$1 {
     /** Whether the operation succeeded */
     success: boolean;
 }
+/** Demand for a single `(day, shift)` slot. */
+interface ShiftDemandInput {
+    /** @min 0 */
+    day: number;
+    /**
+     * Minimum count per role.  The remainder of `total` may be filled
+     * by any eligible agent.  Role names must match tags used in
+     * [`AgentInput::roles`].
+     */
+    role_minimums?: Record<string, number>;
+    /** @min 0 */
+    shift: number;
+    /**
+     * Total number of agents required for this slot.
+     * @format int32
+     * @min 0
+     */
+    total: number;
+}
 /** A single similarity entry for bulk operations */
 interface SimilarityEntry {
     /**
@@ -14254,12 +14370,27 @@ interface SortInfoDto$1 {
 /** Response for sort list operations */
 interface SortListResponse$1 {
     /**
-     * Total count
+     * Number of sorts in **this response** — not the tenant total
+     * when pagination is active.
      * @min 0
      */
     count: number;
-    /** List of sorts */
+    /**
+     * Offset of the first sort in this response.
+     * @min 0
+     */
+    offset?: number;
+    /**
+     * Sorts in this page (or all sorts when no ``limit`` query
+     * parameter was supplied).
+     */
     sorts: SortDto$1[];
+    /**
+     * Total number of sorts the tenant owns after filters, across
+     * all pages. Lets the client know when to stop paginating.
+     * @min 0
+     */
+    total?: number;
 }
 /** API representation of sort origin/provenance */
 type SortOriginDto$1 = {
@@ -15566,6 +15697,73 @@ interface TriggerDependencyResponse$1 {
     /** The visualization graph */
     graph: VisualizationGraphDto$1;
 }
+/**
+ * Request body for `POST /api/v1/triz/invent` — the structured-input,
+ * no-LLM path into the TRIZ invention engine.
+ */
+interface TrizInventRequest {
+    /**
+     * Human-readable context (e.g. "drug_discovery", "kinase_program_279").
+     * The engine uses this in explanations but not in the reasoning.
+     */
+    domain_context?: string;
+    /**
+     * Sort names the caller has pre-seeded under this tenant. Required:
+     * without them the KB-matching step (`query_kb_for_triz_data`) has
+     * no domain hints and falls through to the LLM-synthetic path —
+     * defeating the purpose of this endpoint.
+     */
+    domains?: string[];
+    improving_parameter: string;
+    /** @format uuid */
+    tenant_id: string;
+    worsening_parameter: string;
+}
+/** Request body for `POST /api/v1/triz/record-outcome`. */
+interface TrizRecordOutcomeRequest {
+    /**
+     * UUID of the ``triz_inventive_proposal`` term the engine emitted.
+     * @format uuid
+     */
+    invention_term_id: string;
+    /**
+     * Measured performance ratio (e.g. potency fold, selectivity
+     * fold). ``0.0`` if unmeasured — the engine still records the
+     * success/failure signal.
+     * @format double
+     */
+    measured_ratio?: number;
+    /** Free-text notes on the outcome for downstream audit. */
+    notes?: string;
+    /**
+     * Whether the invention succeeded in downstream validation /
+     * experimental testing.
+     */
+    success: boolean;
+    /** @format uuid */
+    tenant_id: string;
+}
+/** Response payload for outcome recording. */
+interface TrizRecordOutcomeResponse {
+    error?: string | null;
+    /**
+     * Number of learned-mapping terms whose confidence was adjusted.
+     * @min 0
+     */
+    mappings_updated: number;
+    /**
+     * UUID of the newly-created ``triz_invention_outcome`` audit term.
+     * @format uuid
+     */
+    outcome_term_id?: string | null;
+    recorded: boolean;
+    success: boolean;
+    /**
+     * New post-update average confidence across the adjusted mappings.
+     * @format double
+     */
+    updated_confidence: number;
+}
 /** DTO for UIAction — all actions reference OSFQL execution */
 type UIActionDto$1 = {
     field_types: Record<string, string>;
@@ -16748,10 +16946,26 @@ declare class Sorts<SecurityDataType = unknown> {
          * Defaults to false (system sorts are excluded by default).
          */
         include_system?: boolean;
+        /**
+         * Maximum number of sorts to return. When omitted, no cap is
+         * applied (legacy behaviour). Recommended page size for
+         * production tenants: 50_000.
+         * @min 0
+         */
+        limit?: number | null;
         /** Filter to only show LLM-extracted sorts */
         llm_extracted?: boolean | null;
         /** Filter to only show sorts needing review */
         needs_review?: boolean | null;
+        /**
+         * Zero-indexed pagination offset. Combined with ``limit`` this
+         * lets clients stream a production tenant (1 M+ sorts, ~500 MB
+         * uncompressed) as a sequence of small responses, avoiding the
+         * ``IncompleteRead`` a single-response transfer reliably hits
+         * above ~30 MB.
+         * @min 0
+         */
+        offset?: number | null;
     }, params?: RequestParams) => Promise<HttpResponse<SortListResponse$1, any>>;
     /**
      * @description POST /api/v1/sorts/learned-similarities/reject Rejects a proposed or conflicted learned similarity with a reason. Rejected similarities are not used in reasoning.
@@ -20551,6 +20765,26 @@ declare class Query<SecurityDataType = unknown> {
      * @secure
      */
     osfSearch: (data: OsfSearchRequest$1, params?: RequestParams) => Promise<HttpResponse<OsfSearchResponse$1, any>>;
+    /**
+     * @description Skips the NL → structured-problem LLM hop entirely. Caller must have seeded the tenant KB with ≥ 3 successful + ≥ 2 limited Ψ-terms per domain (`/api/v1/terms/bulk` or `/api/v1/inference/facts/bulk`). Returns the same `NlQueryResponse` shape as the NL route so the UI can render either output uniformly.
+     *
+     * @tags query
+     * @name TrizInvent
+     * @summary Handle `POST /api/v1/triz/invent` — deterministic TRIZ invention.
+     * @request POST:/api/v1/triz/invent
+     * @secure
+     */
+    trizInvent: (data: TrizInventRequest, params?: RequestParams) => Promise<HttpResponse<NlQueryResponse$1, any>>;
+    /**
+     * No description
+     *
+     * @tags query
+     * @name TrizRecordOutcome
+     * @summary Handle `POST /api/v1/triz/record-outcome` — persist a measured outcome for a previously-emitted TRIZ proposal and learn from it.
+     * @request POST:/api/v1/triz/record-outcome
+     * @secure
+     */
+    trizRecordOutcome: (data: TrizRecordOutcomeRequest, params?: RequestParams) => Promise<HttpResponse<TrizRecordOutcomeResponse, any>>;
     /**
      * @description This performs unification AND validates the result against the GLB sort's witnesses. ## How It Differs from Regular Unification **Regular `/api/v1/term-store/sessions/:id/unify` (POST)**: - Computes GLB and unifies terms - Validates sort constraints (required features, type hints) - Does NOT check witnesses **This endpoint `/api/v1/query/validated-unify` (POST)**: - Computes GLB and unifies terms - Validates sort constraints - ALSO checks witnesses on the result - Returns proof of validity ## Example Unifying `person(name => "Alice")` with `grandparent(grandchild => "Charlie")`: 1. Computes GLB of person and grandparent 2. Creates unified term with both features 3. Checks grandparent witnesses: ∃Y. parent(Alice,Y) ∧ parent(Y,Charlie) 4. Returns unified term + witness proof
      *
@@ -30924,6 +31158,14 @@ interface CommitRequest {
  * - `"solutions"`: enumerate complete, valid assignments (default — backward compatible).
  * - `"feasibility"`: run 2×N per-variable SAT queries and return reachability info.
  *   Much faster than full enumeration for large spaces.
+ *
+ * For scheduling-shaped problems (staff rostering, vehicle-to-route
+ * assignment, task-to-worker matching, etc.) use the dedicated
+ * {@link SchedulingClient.feasibility | `client.scheduling.feasibility()`}
+ * endpoint instead of routing through `ComputationSpace`. It accepts a
+ * native scheduling problem definition and returns structured per-cell
+ * feasibility classifications — no string-encoded variable names on the
+ * wire, and it preserves real role names end-to-end.
  */
 type SearchModeDto = 'solutions' | 'feasibility';
 /**
@@ -39011,6 +39253,223 @@ declare class OptimizeClient {
     private cleanupArtifacts;
 }
 
+declare class Scheduling<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @description Classify every `(agent, day, shift)` cell in the input grid as confirmed-true, confirmed-false, or free. Input validation errors (duplicate agent IDs, out-of-range pins, role minima exceeding total demand, etc.) return HTTP 400. Infeasibility of a well-formed problem is a valid answer and returns HTTP 200 with `status = "infeasible"` and an empty `assignments` list.
+     *
+     * @tags scheduling
+     * @name Feasibility
+     * @summary `POST /api/v1/scheduling/feasibility`
+     * @request POST:/api/v1/scheduling/feasibility
+     */
+    feasibility: (data: SchedulingFeasibilityRequest$1, params?: RequestParams) => Promise<HttpResponse<SchedulingFeasibilityResponse$1, void>>;
+}
+
+/**
+ * Per-cell feasibility classification produced by the scheduling engine.
+ *
+ * @remarks
+ * Every `(agent, day, shift)` cell in the input grid is classified as
+ * exactly one of these values.  The flow engine is exact — there is no
+ * "unverified" outcome.
+ *
+ * - `"confirmed_true"` — the agent MUST work this slot in every valid schedule.
+ * - `"confirmed_false"` — the agent CANNOT work this slot in any valid schedule.
+ * - `"free"` — the agent's assignment to this slot varies across valid schedules.
+ */
+type AssignmentStatus = 'confirmed_true' | 'confirmed_false' | 'free';
+/**
+ * Top-level scheduling request status.
+ *
+ * @remarks
+ * - `"feasible"` — a valid schedule exists; `assignments` contains per-cell
+ *   classifications.
+ * - `"infeasible"` — no valid schedule exists; `assignments` is empty.
+ */
+type SchedulingStatus = 'feasible' | 'infeasible';
+/**
+ * A single agent that may be assigned to slots.
+ */
+interface AgentSpec {
+    /** Caller-chosen identifier.  Must be unique within the request. */
+    id: string;
+    /**
+     * Role tags this agent carries (e.g. `"icu"`, `"senior"`).  Used to
+     * satisfy per-role minimum-demand constraints.  Defaults to an empty
+     * array if omitted.
+     */
+    roles?: string[];
+    /**
+     * Maximum number of slots this agent may be assigned across the full
+     * horizon.
+     */
+    maxAssignments: number;
+    /**
+     * Day indices on which the agent is unavailable for any shift.
+     * Defaults to an empty array if omitted.
+     */
+    unavailableDays?: number[];
+    /**
+     * When present, the agent may only be assigned to this shift index
+     * (all other shifts become unavailable).
+     */
+    restrictedToShift?: number | null;
+}
+/**
+ * Demand for a single `(day, shift)` slot.
+ */
+interface ShiftDemand {
+    /** Day index (0..days). */
+    day: number;
+    /** Shift index (0..shiftsPerDay). */
+    shift: number;
+    /** Total number of agents required for this slot. */
+    total: number;
+    /**
+     * Minimum count per role.  The remainder of `total` may be filled by
+     * any eligible agent.  Role names must match tags used in
+     * {@link AgentSpec.roles}.
+     */
+    roleMinimums?: Record<string, number>;
+}
+/**
+ * A pre-assigned `(agent, day, shift)` triple.  The engine treats the
+ * pin as confirmed-true and reduces the slot's remaining demand.
+ */
+interface Pin {
+    agentId: string;
+    day: number;
+    shift: number;
+}
+/**
+ * Input to {@link SchedulingClient.feasibility}.
+ *
+ * @remarks
+ * Agents are identified by opaque caller-chosen string IDs so the
+ * response can be joined back to whatever identity the caller maintains
+ * (employee numbers, user IDs, UUIDs, display names, …).
+ */
+interface SchedulingFeasibilityRequest {
+    /** All agents that may be assigned to slots. */
+    agents: AgentSpec[];
+    /** Number of days in the scheduling horizon.  Valid day indices are `0..days`. */
+    days: number;
+    /** Number of shifts per day.  Valid shift indices are `0..shiftsPerDay`. */
+    shiftsPerDay: number;
+    /** Per-slot demand.  At most one entry per `(day, shift)` pair. */
+    demands: ShiftDemand[];
+    /** Pre-assigned `(agent, day, shift)` triples.  Defaults to empty. */
+    pins?: Pin[];
+}
+/**
+ * One classified cell in the input grid.
+ */
+interface Assignment {
+    /** Echoes the `id` from {@link AgentSpec}. */
+    agentId: string;
+    day: number;
+    shift: number;
+    status: AssignmentStatus;
+}
+/**
+ * Response from {@link SchedulingClient.feasibility}.
+ *
+ * @remarks
+ * - When `status === "feasible"`: `assignments` contains one entry per
+ *   `(agent, day, shift)` triple in the input grid, sorted by
+ *   `(agentId, day, shift)`.
+ * - When `status === "infeasible"`: `assignments` is empty.
+ */
+interface SchedulingFeasibilityResponse {
+    status: SchedulingStatus;
+    assignments: Assignment[];
+}
+
+type scheduling_AgentSpec = AgentSpec;
+type scheduling_Assignment = Assignment;
+type scheduling_AssignmentStatus = AssignmentStatus;
+type scheduling_Pin = Pin;
+type scheduling_SchedulingFeasibilityRequest = SchedulingFeasibilityRequest;
+type scheduling_SchedulingFeasibilityResponse = SchedulingFeasibilityResponse;
+type scheduling_SchedulingStatus = SchedulingStatus;
+type scheduling_ShiftDemand = ShiftDemand;
+declare namespace scheduling {
+  export type { scheduling_AgentSpec as AgentSpec, scheduling_Assignment as Assignment, scheduling_AssignmentStatus as AssignmentStatus, scheduling_Pin as Pin, scheduling_SchedulingFeasibilityRequest as SchedulingFeasibilityRequest, scheduling_SchedulingFeasibilityResponse as SchedulingFeasibilityResponse, scheduling_SchedulingStatus as SchedulingStatus, scheduling_ShiftDemand as ShiftDemand };
+}
+
+/**
+ * Resource client for the scheduling feasibility engine.
+ *
+ * @remarks
+ * The engine classifies every `(agent, day, shift)` cell in a rostering
+ * problem as **confirmed-true**, **confirmed-false**, or **free** using a
+ * capacitated bipartite b-matching (Dinic max-flow + Dulmage–Mendelsohn
+ * residual decomposition).  The structure fits staff rostering
+ * (hospital nurses, call-centre agents, field crews), vehicle-to-route
+ * assignment, and any "cover demand with capacity-limited resources"
+ * problem.
+ *
+ * All agent identities are caller-chosen opaque strings — the SDK round-
+ * trips whatever IDs you pass in, so you can plug employee numbers,
+ * UUIDs, or display names directly into the request.
+ *
+ * @example Basic feasibility query
+ * ```typescript
+ * const report = await client.scheduling.feasibility({
+ *   agents: [
+ *     { id: 'alice', roles: ['icu'],     maxAssignments: 3 },
+ *     { id: 'bob',   roles: ['general'], maxAssignments: 3 },
+ *   ],
+ *   days: 7,
+ *   shiftsPerDay: 3,
+ *   demands: [
+ *     { day: 0, shift: 0, total: 2, roleMinimums: { icu: 1 } },
+ *     // ... one demand per (day, shift) slot you care about
+ *   ],
+ * });
+ *
+ * if (report.status === 'feasible') {
+ *   for (const cell of report.assignments) {
+ *     console.log(cell.agentId, cell.day, cell.shift, '→', cell.status);
+ *   }
+ * }
+ * ```
+ *
+ * @example Pinning pre-decided assignments
+ * ```typescript
+ * const report = await client.scheduling.feasibility({
+ *   ...problem,
+ *   pins: [
+ *     { agentId: 'alice', day: 0, shift: 0 }, // Alice WILL work this slot
+ *   ],
+ * });
+ * ```
+ */
+declare class SchedulingClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: Scheduling);
+    /**
+     * Classify every `(agent, day, shift)` cell in the input grid as
+     * `confirmed_true`, `confirmed_false`, or `free`.
+     *
+     * @param request - the scheduling problem to analyse.
+     * @returns a {@link SchedulingFeasibilityResponse} with per-cell classifications.
+     * @throws If the backend rejects the input (HTTP 400): duplicate agent
+     *   IDs, pins referencing unknown agents, role minima exceeding total
+     *   demand, out-of-range day/shift indices, etc.
+     *
+     * @remarks
+     * Infeasibility of a well-formed problem is a **valid answer** (HTTP 200
+     * with `status === "infeasible"`), not an error.  Only malformed input
+     * raises.
+     */
+    feasibility(request: SchedulingFeasibilityRequest): Promise<SchedulingFeasibilityResponse>;
+}
+
 declare class Osfql<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
@@ -40605,9 +41064,10 @@ interface AiGroup {
     readonly context: ContextClient;
     readonly rlTraining: RlTrainingClient;
 }
-/** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery. */
+/** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
 interface ReasoningGroup {
     readonly optimize: OptimizeClient;
+    readonly scheduling: SchedulingClient;
     readonly ilp: IlpClient;
     readonly cdl: CdlClient;
     readonly execution: ExecutionClient;
@@ -40755,6 +41215,8 @@ declare class ReasoningLayerClient {
     readonly rag: RagClient;
     /** Linear program optimization (CLP(Q) simplex solver via backward chaining). */
     readonly optimize: OptimizeClient;
+    /** Scheduling feasibility via capacitated bipartite b-matching (staff rostering, assignment problems). */
+    readonly scheduling: SchedulingClient;
     /** OSFQL execution operations. */
     readonly osfql: OsfqlClient;
     /** Conversational AI operations (NL → OSFQL with self-correction). */
@@ -40798,7 +41260,7 @@ declare class ReasoningLayerClient {
     get core(): CoreGroup;
     /** AI and machine learning operations — agents, oversight, neuro-symbolic, RAG, generation, context, RL training. */
     get ai(): AiGroup;
-    /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery. */
+    /** Advanced reasoning operations — optimization, ILP, CDL, execution, preferences, discovery, scheduling. */
     get reasoningOps(): ReasoningGroup;
     /** Analysis operations — causal, statistical, fuzzy, scenarios, communities, visualization. */
     get analysisOps(): AnalysisGroup;
@@ -41872,4 +42334,4 @@ declare function toUntaggedFeatures(features: PlainFeatureMap): Record<string, F
  */
 declare function toTermInputDto(input: PsiTermInput | TermInputDto): TermInputDto;
 
-export { actionReviews as ActionReviews, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, type ConstrainedPlainVar, 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, 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, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, 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, 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 { actionReviews as ActionReviews, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, type AiGroup, analysis as Analysis, type AnalysisGroup, ApiError, type ApiResponse, AuthenticationError, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, causal as Causal, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, collections as Collections, communities as Communities, type ConstrainedPlainVar, 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, 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, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, 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 };