@kortexya/reasoninglayer 0.8.0 → 0.9.0

package/dist/index.d.cts

@@ -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.8.0";
+declare const SDK_VERSION = "0.9.0";
 /**
  * Configuration for the Reasoning Layer client.
  *
@@ -6217,6 +6217,93 @@ type FuzzyShapeDto$1 = {
     period: number;
     /** @format double */
     stdDev: number;
+} | {
+    kind: "Sigmoid";
+    /** @format double */
+    midpoint: number;
+    /** @format double */
+    steepness: number;
+} | {
+    kind: "Bell";
+    /** @format double */
+    center: number;
+    /** @format double */
+    width: number;
+    /** @format double */
+    slope: number;
+} | {
+    kind: "SigmoidDifference";
+    /** @format double */
+    midpoint1: number;
+    /** @format double */
+    steepness1: number;
+    /** @format double */
+    midpoint2: number;
+    /** @format double */
+    steepness2: number;
+} | {
+    kind: "GaussianProduct";
+    /** @format double */
+    mean1: number;
+    /** @format double */
+    stdDev1: number;
+    /** @format double */
+    mean2: number;
+    /** @format double */
+    stdDev2: number;
+} | {
+    kind: "SigmoidProduct";
+    /** @format double */
+    midpoint1: number;
+    /** @format double */
+    steepness1: number;
+    /** @format double */
+    midpoint2: number;
+    /** @format double */
+    steepness2: number;
+} | {
+    kind: "Cosine";
+    /** @format double */
+    center: number;
+    /** @format double */
+    width: number;
+} | {
+    kind: "Spike";
+    /** @format double */
+    center: number;
+    /** @format double */
+    width: number;
+} | {
+    kind: "Cauchy";
+    /** @format double */
+    center: number;
+    /** @format double */
+    gamma: number;
+} | {
+    kind: "SShape";
+    /** @format double */
+    a: number;
+    /** @format double */
+    b: number;
+} | {
+    kind: "ZShape";
+    /** @format double */
+    a: number;
+    /** @format double */
+    b: number;
+} | {
+    kind: "PiShape";
+    /** @format double */
+    a: number;
+    /** @format double */
+    b: number;
+    /** @format double */
+    c: number;
+    /** @format double */
+    d: number;
+} | {
+    kind: "PiecewiseLinear";
+    points: [number, number][];
 };
 /** Request for fuzzy subsumption check */
 interface FuzzySubsumptionRequest$1 {
@@ -15570,6 +15657,176 @@ interface CyclicGaussianShape {
     stdDev: number;
     period: number;
 }
+/**
+ * Sigmoid (logistic) fuzzy membership function: monotonic S-curve transition.
+ *
+ * Membership: `μ(x) = 1 / (1 + exp(-steepness * (x - midpoint)))`.
+ * Positive steepness = increasing (left-open), negative = decreasing (right-open).
+ *
+ * Use case: threshold transitions (e.g., DNA match confidence, toxicity cutoffs).
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface SigmoidShape {
+    kind: 'Sigmoid';
+    midpoint: number;
+    steepness: number;
+}
+/**
+ * Generalized bell fuzzy membership function: tunable flat-top bell shape.
+ *
+ * Membership: `μ(x) = 1 / (1 + |((x - center) / width)|^(2*slope))`.
+ * Unlike Gaussian, the slope parameter controls how sharply the curve falls off
+ * and the width parameter controls the flat-top region.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface BellShape {
+    kind: 'Bell';
+    center: number;
+    width: number;
+    slope: number;
+}
+/**
+ * Difference of two sigmoids: creates a smooth bounded region.
+ *
+ * Membership: `μ(x) = sigmoid(x, midpoint1, steepness1) - sigmoid(x, midpoint2, steepness2)`.
+ * Creates a smooth "bump" between two transition points (like a smooth trapezoidal).
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface SigmoidDifferenceShape {
+    kind: 'SigmoidDifference';
+    midpoint1: number;
+    steepness1: number;
+    midpoint2: number;
+    steepness2: number;
+}
+/**
+ * Product of two Gaussians (gauss2mf): asymmetric flat-top bell shape.
+ *
+ * Membership: left Gaussian up to mean1, flat 1.0 in [mean1, mean2],
+ * right Gaussian after mean2.
+ * `μ(x) = exp(-(x - mean1)^2 / (2 * stdDev1^2))` for x < mean1,
+ * `μ(x) = 1` for mean1 <= x <= mean2,
+ * `μ(x) = exp(-(x - mean2)^2 / (2 * stdDev2^2))` for x > mean2.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface GaussianProductShape {
+    kind: 'GaussianProduct';
+    mean1: number;
+    stdDev1: number;
+    mean2: number;
+    stdDev2: number;
+}
+/**
+ * Product of two sigmoids: always non-negative bounded region.
+ *
+ * Membership: `μ(x) = sigmoid(x, midpoint1, steepness1) * sigmoid(x, midpoint2, steepness2)`.
+ * Unlike {@link SigmoidDifferenceShape}, the product is always non-negative.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface SigmoidProductShape {
+    kind: 'SigmoidProduct';
+    midpoint1: number;
+    steepness1: number;
+    midpoint2: number;
+    steepness2: number;
+}
+/**
+ * Cosine fuzzy membership function with compact support.
+ *
+ * Membership: `μ(x) = 0.5 * (1 + cos(2π/width * (x - center)))` for `|x - center| <= width/2`,
+ * `μ(x) = 0` otherwise.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface CosineShape {
+    kind: 'Cosine';
+    center: number;
+    width: number;
+}
+/**
+ * Spike (Laplacian/double-exponential) fuzzy membership function.
+ *
+ * Membership: `μ(x) = exp(-|x - center| / width)`.
+ * Sharp cusp at center with exponential tails.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface SpikeShape {
+    kind: 'Spike';
+    center: number;
+    width: number;
+}
+/**
+ * Cauchy (Lorentzian) fuzzy membership function with heavy tails.
+ *
+ * Membership: `μ(x) = 1 / (1 + ((x - center) / gamma)^2)`.
+ * Unlike Gaussian, the tails never reach zero.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface CauchyShape {
+    kind: 'Cauchy';
+    center: number;
+    gamma: number;
+}
+/**
+ * S-shaped (smf) fuzzy membership function: smooth monotonic spline from 0 to 1.
+ *
+ * Membership: piecewise quadratic transition from 0 at `a` to 1 at `b`.
+ * Unlike {@link SigmoidShape}, reaches exact 0 and 1.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface SShapeShape {
+    kind: 'SShape';
+    a: number;
+    b: number;
+}
+/**
+ * Z-shaped (zmf) fuzzy membership function: smooth monotonic spline from 1 to 0.
+ *
+ * Membership: mirror of {@link SShapeShape}. Piecewise quadratic transition
+ * from 1 at `a` to 0 at `b`.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface ZShapeShape {
+    kind: 'ZShape';
+    a: number;
+    b: number;
+}
+/**
+ * Pi-shaped (pimf) fuzzy membership function: smooth compact flat-top bump.
+ *
+ * Membership: `μ(x) = SShape(x, a, b) * ZShape(x, c, d)`.
+ * Like a smooth {@link TrapezoidalShape}.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface PiShapeShape {
+    kind: 'PiShape';
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}
+/**
+ * Piecewise linear fuzzy membership function defined by (x, mu) data points.
+ *
+ * Membership is linearly interpolated between the provided points.
+ * Each point is a `[x, mu]` tuple where `mu` is the membership degree.
+ *
+ * @remarks Discriminator field is `"kind"`, NOT `"type"`.
+ */
+interface PiecewiseLinearShape {
+    kind: 'PiecewiseLinear';
+    points: [number, number][];
+}
 /**
  * Fuzzy membership function shape.
  *
@@ -15582,10 +15839,11 @@ interface CyclicGaussianShape {
  * @example
  * ```json
  * {"kind": "Triangular", "a": 20, "b": 22, "c": 24}
- * {"kind": "Gaussian", "mean": 100, "std_dev": 15}
+ * {"kind": "Gaussian", "mean": 100, "stdDev": 15}
+ * {"kind": "Sigmoid", "midpoint": 0.95, "steepness": 20}
  * ```
  */
-type FuzzyShapeDto = TriangularShape | TrapezoidalShape | GaussianShape | CyclicGaussianShape;
+type FuzzyShapeDto = TriangularShape | TrapezoidalShape | GaussianShape | CyclicGaussianShape | SigmoidShape | BellShape | SigmoidDifferenceShape | GaussianProductShape | SigmoidProductShape | CosineShape | SpikeShape | CauchyShape | SShapeShape | ZShapeShape | PiShapeShape | PiecewiseLinearShape;
 /**
  * Tagged feature value types used in OsfConstraintDto Feature variant.
  *
@@ -15644,27 +15902,39 @@ type FeatureTargetDto = TaggedFeatureValueDto | string;
  */
 type FeatureValueDto = string | number | boolean | null | FeatureValueDto[];
 
+type values_BellShape = BellShape;
 type values_BooleanValue = BooleanValue;
+type values_CauchyShape = CauchyShape;
+type values_CosineShape = CosineShape;
 type values_CyclicGaussianShape = CyclicGaussianShape;
 type values_FeatureTargetDto = FeatureTargetDto;
 type values_FeatureValueDto = FeatureValueDto;
 type values_FuzzyNumberValue = FuzzyNumberValue;
 type values_FuzzyScalarValue = FuzzyScalarValue;
 type values_FuzzyShapeDto = FuzzyShapeDto;
+type values_GaussianProductShape = GaussianProductShape;
 type values_GaussianShape = GaussianShape;
 type values_IntegerValue = IntegerValue;
 type values_ListValue = ListValue;
+type values_PiShapeShape = PiShapeShape;
+type values_PiecewiseLinearShape = PiecewiseLinearShape;
 type values_RealValue = RealValue;
 type values_ReferenceValue = ReferenceValue;
+type values_SShapeShape = SShapeShape;
 type values_SetValue = SetValue;
+type values_SigmoidDifferenceShape = SigmoidDifferenceShape;
+type values_SigmoidProductShape = SigmoidProductShape;
+type values_SigmoidShape = SigmoidShape;
+type values_SpikeShape = SpikeShape;
 type values_StringValue = StringValue;
 type values_TaggedFeatureValueDto = TaggedFeatureValueDto;
 type values_TrapezoidalShape = TrapezoidalShape;
 type values_TriangularShape = TriangularShape;
 type values_UninstantiatedValue = UninstantiatedValue;
 type values_ValueDto = ValueDto;
+type values_ZShapeShape = ZShapeShape;
 declare namespace values {
-  export type { values_BooleanValue as BooleanValue, values_CyclicGaussianShape as CyclicGaussianShape, values_FeatureTargetDto as FeatureTargetDto, values_FeatureValueDto as FeatureValueDto, values_FuzzyNumberValue as FuzzyNumberValue, values_FuzzyScalarValue as FuzzyScalarValue, values_FuzzyShapeDto as FuzzyShapeDto, values_GaussianShape as GaussianShape, values_IntegerValue as IntegerValue, values_ListValue as ListValue, values_RealValue as RealValue, values_ReferenceValue as ReferenceValue, values_SetValue as SetValue, values_StringValue as StringValue, values_TaggedFeatureValueDto as TaggedFeatureValueDto, values_TrapezoidalShape as TrapezoidalShape, values_TriangularShape as TriangularShape, values_UninstantiatedValue as UninstantiatedValue, values_ValueDto as ValueDto };
+  export type { values_BellShape as BellShape, values_BooleanValue as BooleanValue, values_CauchyShape as CauchyShape, values_CosineShape as CosineShape, values_CyclicGaussianShape as CyclicGaussianShape, values_FeatureTargetDto as FeatureTargetDto, values_FeatureValueDto as FeatureValueDto, values_FuzzyNumberValue as FuzzyNumberValue, values_FuzzyScalarValue as FuzzyScalarValue, values_FuzzyShapeDto as FuzzyShapeDto, values_GaussianProductShape as GaussianProductShape, values_GaussianShape as GaussianShape, values_IntegerValue as IntegerValue, values_ListValue as ListValue, values_PiShapeShape as PiShapeShape, values_PiecewiseLinearShape as PiecewiseLinearShape, values_RealValue as RealValue, values_ReferenceValue as ReferenceValue, values_SShapeShape as SShapeShape, values_SetValue as SetValue, values_SigmoidDifferenceShape as SigmoidDifferenceShape, values_SigmoidProductShape as SigmoidProductShape, values_SigmoidShape as SigmoidShape, values_SpikeShape as SpikeShape, values_StringValue as StringValue, values_TaggedFeatureValueDto as TaggedFeatureValueDto, values_TrapezoidalShape as TrapezoidalShape, values_TriangularShape as TriangularShape, values_UninstantiatedValue as UninstantiatedValue, values_ValueDto as ValueDto, values_ZShapeShape as ZShapeShape };
 }
 
 /**
@@ -21507,7 +21777,7 @@ declare class FuzzyClient {
      * @returns Similarity comparison result.
      * @see fuzzyUnify
      */
-    compareSimilarity(term1Id: string, term2Id: string, options?: Partial<Omit<FuzzyUnifyRequest, 'term1_id' | 'term2_id'>>): Promise<FuzzyUnifyResponse>;
+    compareSimilarity(term1Id: string, term2Id: string, options?: Partial<Omit<FuzzyUnifyRequest, 'term1Id' | 'term2Id'>>): Promise<FuzzyUnifyResponse>;
     /**
      * Fuzzy merge two terms.
      *
@@ -37304,6 +37574,686 @@ declare class ConversationClient {
     deleteConversation(conversationId: string): Promise<void>;
 }
 
+/** Source of paper metadata. */
+type PaperSource = 'PubMed' | 'SemanticScholar' | 'CrossRef' | 'ArXiv';
+/** Request to search for papers across external sources. */
+interface SearchPapersRequest {
+    /** Search query string. */
+    query: string;
+    /** Maximum number of results to return. */
+    maxResults?: number;
+    /** Restrict to specific sources. */
+    sources?: PaperSource[];
+}
+/** Metadata about a scientific paper. */
+interface PaperMetadataDto {
+    /** Paper title. */
+    title: string;
+    /** Author names. */
+    authors: string[];
+    /** Digital Object Identifier. */
+    doi?: string | null;
+    /** PubMed ID. */
+    pmid?: string | null;
+    /** arXiv ID. */
+    arxivId?: string | null;
+    /** Journal or venue name. */
+    journal?: string | null;
+    /** Publication year. */
+    year?: number | null;
+    /** Abstract text. */
+    abstractText?: string | null;
+    /** Citation count. */
+    citationCount?: number | null;
+    /** Source database. */
+    source: PaperSource;
+    /** URL to full text. */
+    fullTextUrl?: string | null;
+}
+/** A search result with relevance score. */
+interface PaperSearchResultDto {
+    /** Paper metadata. */
+    metadata: PaperMetadataDto;
+    /** Relevance score (0.0-1.0). */
+    relevanceScore?: number | null;
+}
+/** Response from paper search. */
+interface SearchPapersResponse {
+    /** Search results. */
+    results: PaperSearchResultDto[];
+    /** Total results found (may exceed returned count). */
+    totalFound: number;
+}
+/** Status of a research session. */
+type ResearchSessionStatusDto = 'Created' | 'Bootstrapping' | 'Retrieving' | 'Ingesting' | 'Verifying' | 'Reporting' | 'Completed' | 'Failed';
+/** Request to create a new research session. */
+interface CreateResearchSessionRequest {
+    /** The research question to investigate. */
+    question: string;
+    /** Maximum number of research cycles. */
+    maxCycles?: number;
+    /** Maximum number of papers to ingest. */
+    maxPapers?: number;
+    /** Restrict paper search to specific sources. */
+    paperSources?: PaperSource[];
+}
+/** Response from creating a research session. */
+interface CreateResearchSessionResponse {
+    /** Session ID (UUID). */
+    sessionId: string;
+    /** Current session status. */
+    status: ResearchSessionStatusDto;
+    /** The research question. */
+    question: string;
+    /** When the session was created (ISO 8601). */
+    createdAt: string;
+}
+/** Full research session state. */
+interface ResearchSessionResponse {
+    /** Session ID (UUID). */
+    sessionId: string;
+    /** The research question. */
+    question: string;
+    /** Current session status. */
+    status: ResearchSessionStatusDto;
+    /** Error message if status is Failed. */
+    error?: string | null;
+    /** Results from each completed cycle. */
+    cycles: ResearchCycleResultDto[];
+    /** Total papers ingested. */
+    totalPapersIngested: number;
+    /** Total findings. */
+    totalFindings: number;
+    /** Total contradictions. */
+    totalContradictions: number;
+    /** Total knowledge gaps. */
+    totalGaps: number;
+    /** When the session was created (ISO 8601). */
+    createdAt: string;
+    /** When the session was last updated (ISO 8601). */
+    updatedAt: string;
+}
+/** Results from a single research cycle. */
+interface ResearchCycleResultDto {
+    /** Cycle number (1-indexed). */
+    cycleNumber: number;
+    /** Knowledge gaps detected at start of cycle. */
+    gapsDetected: number;
+    /** Gaps resolved during this cycle. */
+    gapsResolved: number;
+    /** Papers retrieved from external APIs. */
+    papersRetrieved: number;
+    /** Papers successfully ingested. */
+    papersIngested: number;
+    /** Claims verified. */
+    claimsVerified: number;
+    /** Contradictions detected. */
+    contradictionsDetected: number;
+    /** Processing time for this cycle in milliseconds. */
+    processingTimeMs: number;
+    /** Search queries used. */
+    searchQueries: string[];
+}
+/** Optional parameters for running a research cycle. */
+interface RunResearchCycleRequest {
+    /** Additional search queries to include. */
+    additionalQueries?: string[];
+    /** Override maximum papers for this cycle. */
+    maxPapersThisCycle?: number;
+}
+/** Response from running a research cycle. */
+interface ResearchCycleResponse {
+    /** Session ID. */
+    sessionId: string;
+    /** Current session status after cycle. */
+    status: ResearchSessionStatusDto;
+    /** Results from this cycle. */
+    cycle: ResearchCycleResultDto;
+    /** Whether the session has converged (no more cycles needed). */
+    converged: boolean;
+}
+/** Summary of a single evidence item. */
+interface EvidenceItemSummaryDto {
+    /** OSFKB term ID of the evidence. */
+    termId: string;
+    /** Description of the evidence. */
+    description: string;
+    /** Quality weight (0.0-1.0). */
+    qualityWeight: number;
+    /** Whether this evidence supports the claim. */
+    supports: boolean;
+    /** Contribution to the overall assessment. */
+    contribution: number;
+    /** DOI of the paper providing this evidence. */
+    paperDoi?: string | null;
+}
+/** A step in the provenance chain. */
+interface ProvenanceStepDto {
+    /** Type of step: "extraction", "inference", "assessment". */
+    stepType: string;
+    /** Description of what happened. */
+    description: string;
+    /** OSFKB entity ID involved. */
+    entityId?: string | null;
+    /** Timestamp (ISO 8601). */
+    timestamp?: string | null;
+}
+/** A verified research finding. */
+interface ResearchFindingDto {
+    /** OSFKB term ID of the claim. */
+    claimId: string;
+    /** The claim statement. */
+    statement: string;
+    /** Evidence assessment truthfulness score (0.0-1.0). */
+    truthfulness: number;
+    /** Assessment label. */
+    label: string;
+    /** Supporting evidence items. */
+    supportingEvidence: EvidenceItemSummaryDto[];
+    /** Contradicting evidence items. */
+    contradictingEvidence: EvidenceItemSummaryDto[];
+    /** Full provenance chain. */
+    provenanceChain: ProvenanceStepDto[];
+    /** Whether assessment was residuated. */
+    residuated: boolean;
+    /** Reason for residuation. */
+    residuationReason?: string | null;
+}
+/** Response containing research findings. */
+interface ResearchFindingsResponse {
+    /** Session ID. */
+    sessionId: string;
+    /** Verified findings. */
+    findings: ResearchFindingDto[];
+    /** Total findings count. */
+    total: number;
+}
+/** A knowledge gap identified by goal residuation. */
+interface KnowledgeGapDto {
+    /** The sort name that is missing. */
+    sortName: string;
+    /** Information gain score. */
+    infoGain: number;
+    /** Rule head names that need this sort. */
+    neededBy: string[];
+    /** What would resolve this gap. */
+    wakeTrigger: string;
+    /** Suggested search query. */
+    suggestedSearchQuery?: string | null;
+}
+/** Response containing knowledge gaps. */
+interface ResearchGapsResponse {
+    /** Session ID. */
+    sessionId: string;
+    /** Knowledge gaps. */
+    gaps: KnowledgeGapDto[];
+    /** Total gaps count. */
+    total: number;
+}
+/** A detected contradiction between two claims. */
+interface ContradictionDto {
+    /** OSFKB term ID of the first claim. */
+    claimAId: string;
+    /** OSFKB term ID of the second claim. */
+    claimBId: string;
+    /** Statement of the first claim. */
+    statementA: string;
+    /** Statement of the second claim. */
+    statementB: string;
+    /** Disentailment confidence score. */
+    confidence: number;
+    /** Explanation of the contradiction. */
+    explanation: string;
+}
+/** Response containing contradictions. */
+interface ResearchContradictionsResponse {
+    /** Session ID. */
+    sessionId: string;
+    /** Contradictions. */
+    contradictions: ContradictionDto[];
+    /** Total contradictions count. */
+    total: number;
+}
+/** Research statistics. */
+interface ResearchStatisticsDto {
+    /** Total research cycles. */
+    totalCycles: number;
+    /** Total papers retrieved. */
+    totalPapersRetrieved: number;
+    /** Total papers ingested. */
+    totalPapersIngested: number;
+    /** Total claims extracted. */
+    totalClaimsExtracted: number;
+    /** Total claims verified. */
+    totalClaimsVerified: number;
+    /** Total contradictions detected. */
+    totalContradictions: number;
+    /** Total processing time in milliseconds. */
+    totalProcessingTimeMs: number;
+    /** Knowledge gaps resolved. */
+    gapsResolved: number;
+    /** Knowledge gaps remaining. */
+    gapsRemaining: number;
+}
+/** Report verification result. */
+interface ReportVerificationDto {
+    /** Overall verdict. */
+    verdict: string;
+    /** Verification score (0.0-1.0). */
+    score: number;
+    /** Computation time in milliseconds. */
+    computationTimeMs: number;
+}
+/** Full research report response. */
+interface ResearchReportResponse {
+    /** Session ID. */
+    sessionId: string;
+    /** The original research question. */
+    question: string;
+    /** Executive summary. */
+    summary: string;
+    /** Verified findings. */
+    findings: ResearchFindingDto[];
+    /** Unresolved knowledge gaps. */
+    knowledgeGaps: KnowledgeGapDto[];
+    /** Detected contradictions. */
+    contradictions: ContradictionDto[];
+    /** Research statistics. */
+    statistics: ResearchStatisticsDto;
+    /** Generated report content (markdown). */
+    generatedContent?: string | null;
+    /** Oversight verification result. */
+    verification?: ReportVerificationDto | null;
+}
+/** Request to ingest a specific paper. */
+interface IngestPaperRequest {
+    /** Paper identifier (DOI, PMID, arXiv ID, or URL). */
+    identifier: string;
+    /** Type of identifier. */
+    identifierType: 'doi' | 'pmid' | 'arxiv_id' | 'url';
+    /** Session ID to associate ingestion with. */
+    sessionId?: string | null;
+}
+/** Response from paper ingestion. */
+interface IngestPaperResponse {
+    /** Whether ingestion succeeded. */
+    success: boolean;
+    /** Paper metadata. */
+    metadata?: PaperMetadataDto | null;
+    /** Number of entities extracted. */
+    entitiesExtracted: number;
+    /** Number of claims extracted. */
+    claimsExtracted: number;
+    /** Error message if failed. */
+    error?: string | null;
+}
+/** Request to verify a specific claim. */
+interface VerifyClaimRequest {
+    /** Claim term ID (UUID). */
+    claimTermId: string;
+    /** Evidence sort ID (UUID). */
+    evidenceSortId: string;
+}
+/** Response from claim verification. */
+interface VerifyClaimResponse {
+    /** Truthfulness score (0.0-1.0). */
+    truthfulness: number;
+    /** Assessment label. */
+    label: string;
+    /** Number of supporting evidence items. */
+    supportingCount: number;
+    /** Number of contradicting evidence items. */
+    contradictingCount: number;
+    /** Whether assessment was residuated. */
+    residuated: boolean;
+    /** Reason for residuation. */
+    residuationReason?: string | null;
+}
+
+type research_ContradictionDto = ContradictionDto;
+type research_CreateResearchSessionRequest = CreateResearchSessionRequest;
+type research_CreateResearchSessionResponse = CreateResearchSessionResponse;
+type research_EvidenceItemSummaryDto = EvidenceItemSummaryDto;
+type research_IngestPaperRequest = IngestPaperRequest;
+type research_IngestPaperResponse = IngestPaperResponse;
+type research_KnowledgeGapDto = KnowledgeGapDto;
+type research_PaperMetadataDto = PaperMetadataDto;
+type research_PaperSearchResultDto = PaperSearchResultDto;
+type research_PaperSource = PaperSource;
+type research_ProvenanceStepDto = ProvenanceStepDto;
+type research_ReportVerificationDto = ReportVerificationDto;
+type research_ResearchContradictionsResponse = ResearchContradictionsResponse;
+type research_ResearchCycleResponse = ResearchCycleResponse;
+type research_ResearchCycleResultDto = ResearchCycleResultDto;
+type research_ResearchFindingDto = ResearchFindingDto;
+type research_ResearchFindingsResponse = ResearchFindingsResponse;
+type research_ResearchGapsResponse = ResearchGapsResponse;
+type research_ResearchReportResponse = ResearchReportResponse;
+type research_ResearchSessionResponse = ResearchSessionResponse;
+type research_ResearchSessionStatusDto = ResearchSessionStatusDto;
+type research_ResearchStatisticsDto = ResearchStatisticsDto;
+type research_RunResearchCycleRequest = RunResearchCycleRequest;
+type research_SearchPapersRequest = SearchPapersRequest;
+type research_SearchPapersResponse = SearchPapersResponse;
+type research_VerifyClaimRequest = VerifyClaimRequest;
+type research_VerifyClaimResponse = VerifyClaimResponse;
+declare namespace research {
+  export type { research_ContradictionDto as ContradictionDto, research_CreateResearchSessionRequest as CreateResearchSessionRequest, research_CreateResearchSessionResponse as CreateResearchSessionResponse, research_EvidenceItemSummaryDto as EvidenceItemSummaryDto, research_IngestPaperRequest as IngestPaperRequest, research_IngestPaperResponse as IngestPaperResponse, research_KnowledgeGapDto as KnowledgeGapDto, research_PaperMetadataDto as PaperMetadataDto, research_PaperSearchResultDto as PaperSearchResultDto, research_PaperSource as PaperSource, research_ProvenanceStepDto as ProvenanceStepDto, research_ReportVerificationDto as ReportVerificationDto, research_ResearchContradictionsResponse as ResearchContradictionsResponse, research_ResearchCycleResponse as ResearchCycleResponse, research_ResearchCycleResultDto as ResearchCycleResultDto, research_ResearchFindingDto as ResearchFindingDto, research_ResearchFindingsResponse as ResearchFindingsResponse, research_ResearchGapsResponse as ResearchGapsResponse, research_ResearchReportResponse as ResearchReportResponse, research_ResearchSessionResponse as ResearchSessionResponse, research_ResearchSessionStatusDto as ResearchSessionStatusDto, research_ResearchStatisticsDto as ResearchStatisticsDto, research_RunResearchCycleRequest as RunResearchCycleRequest, research_SearchPapersRequest as SearchPapersRequest, research_SearchPapersResponse as SearchPapersResponse, research_VerifyClaimRequest as VerifyClaimRequest, research_VerifyClaimResponse as VerifyClaimResponse };
+}
+
+/**
+ * Resource client for verified scientific research pipeline operations.
+ *
+ * @remarks
+ * Wraps the scientific-research microservice endpoints which orchestrate
+ * a multi-cycle research pipeline: paper retrieval, ingestion into the
+ * OSFKB, claim extraction, evidence assessment via backward chaining,
+ * contradiction detection via disentailment, knowledge gap analysis via
+ * goal residuation, and report generation with FormalJudge verification.
+ *
+ * Research sessions progress through states: Created -> Bootstrapping ->
+ * Retrieving -> Ingesting -> Verifying -> Reporting -> Completed (or Failed).
+ *
+ * Delegates to the generated HTTP client for type-safe transport with
+ * automatic serialization, authentication, retry, and timeout behavior.
+ */
+declare class ResearchClient {
+    /** @internal */
+    private readonly http;
+    /** @internal */
+    constructor(http: HttpClient);
+    /**
+     * Create a new research session for a given research question.
+     *
+     * @param request - The research session creation request.
+     * @returns The created session with its ID, status, and creation timestamp.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Initializes a new research pipeline session. The session starts in
+     * "Created" status and must be advanced by calling {@link runCycle} or
+     * {@link runToCompletion}.
+     *
+     * @example
+     * ```typescript
+     * const session = await client.research.createSession({
+     *   question: 'What are the mechanisms of antibiotic resistance in E. coli?',
+     *   maxCycles: 5,
+     *   maxPapers: 50,
+     *   paperSources: ['PubMed', 'SemanticScholar'],
+     * });
+     * console.log(session.sessionId); // UUID
+     * console.log(session.status);    // "Created"
+     * ```
+     */
+    createSession(request: CreateResearchSessionRequest): Promise<CreateResearchSessionResponse>;
+    /**
+     * Get the current state of a research session.
+     *
+     * @param sessionId - The session ID (UUID).
+     * @returns Full session state including cycles, totals, and timestamps.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Returns the complete session state including all completed cycle results,
+     * aggregate counts (papers ingested, findings, contradictions, gaps), and
+     * the current session status.
+     *
+     * @example
+     * ```typescript
+     * const session = await client.research.getSession('session-uuid');
+     * console.log(session.status);              // "Completed"
+     * console.log(session.totalPapersIngested);  // 42
+     * console.log(session.totalFindings);        // 17
+     * console.log(session.cycles.length);        // 3
+     * ```
+     */
+    getSession(sessionId: string): Promise<ResearchSessionResponse>;
+    /**
+     * Run a single research cycle within a session.
+     *
+     * @param sessionId - The session ID (UUID).
+     * @param request - Optional parameters for the cycle (additional queries, paper limit).
+     * @returns Cycle results and whether the session has converged.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Executes one iteration of the research pipeline: detect knowledge gaps,
+     * generate search queries, retrieve papers, ingest into OSFKB, verify
+     * claims, and detect contradictions. The `converged` field indicates
+     * whether further cycles are needed.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.research.runCycle('session-uuid', {
+     *   additionalQueries: ['beta-lactamase gene transfer'],
+     *   maxPapersThisCycle: 10,
+     * });
+     * console.log(result.cycle.papersIngested);       // 8
+     * console.log(result.cycle.contradictionsDetected); // 1
+     * console.log(result.converged);                    // false
+     * ```
+     */
+    runCycle(sessionId: string, request?: RunResearchCycleRequest): Promise<ResearchCycleResponse>;
+    /**
+     * Run the research session to completion (all remaining cycles).
+     *
+     * @param sessionId - The session ID (UUID).
+     * @returns Final session state after all cycles have completed.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Runs cycles until convergence (no new knowledge gaps) or the maximum
+     * cycle count is reached. This may take significant time depending on
+     * the research question complexity and paper availability.
+     *
+     * @example
+     * ```typescript
+     * const session = await client.research.runToCompletion('session-uuid');
+     * console.log(session.status);              // "Completed"
+     * console.log(session.totalPapersIngested);  // 47
+     * console.log(session.cycles.length);        // 4
+     * ```
+     */
+    runToCompletion(sessionId: string): Promise<ResearchSessionResponse>;
+    /**
+     * Delete a research session and all associated data.
+     *
+     * @param sessionId - The session ID (UUID) to delete.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Permanently removes the session, its cycles, findings, gaps, and
+     * contradictions. This operation cannot be undone.
+     *
+     * @example
+     * ```typescript
+     * await client.research.deleteSession('session-uuid');
+     * ```
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Get verified findings for a research session.
+     *
+     * @param sessionId - The session ID (UUID).
+     * @returns Findings with evidence assessments, provenance chains, and residuation status.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Returns all claims that have been verified through evidence assessment.
+     * Each finding includes supporting and contradicting evidence items,
+     * a truthfulness score, and the full provenance chain from paper to claim.
+     *
+     * @example
+     * ```typescript
+     * const { findings, total } = await client.research.getFindings('session-uuid');
+     * for (const finding of findings) {
+     *   console.log(`${finding.statement}: ${finding.label} (${finding.truthfulness})`);
+     *   console.log(`  Supporting: ${finding.supportingEvidence.length}`);
+     *   console.log(`  Contradicting: ${finding.contradictingEvidence.length}`);
+     * }
+     * ```
+     */
+    getFindings(sessionId: string): Promise<ResearchFindingsResponse>;
+    /**
+     * Get knowledge gaps for a research session.
+     *
+     * @param sessionId - The session ID (UUID).
+     * @returns Knowledge gaps with information gain scores and suggested queries.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Returns sorts that are needed by rule heads but have no matching facts,
+     * identified via goal residuation. Each gap includes the information gain
+     * score, the rules that need it, and a suggested search query to resolve it.
+     *
+     * @example
+     * ```typescript
+     * const { gaps, total } = await client.research.getGaps('session-uuid');
+     * for (const gap of gaps) {
+     *   console.log(`Missing: ${gap.sortName} (info gain: ${gap.infoGain})`);
+     *   console.log(`  Needed by: ${gap.neededBy.join(', ')}`);
+     *   if (gap.suggestedSearchQuery) {
+     *     console.log(`  Suggested query: ${gap.suggestedSearchQuery}`);
+     *   }
+     * }
+     * ```
+     */
+    getGaps(sessionId: string): Promise<ResearchGapsResponse>;
+    /**
+     * Get detected contradictions for a research session.
+     *
+     * @param sessionId - The session ID (UUID).
+     * @returns Contradictions with claim pairs, confidence scores, and explanations.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Returns pairs of claims where disentailment has been detected. Each
+     * contradiction includes both claim statements, a confidence score, and
+     * an explanation of the logical conflict.
+     *
+     * @example
+     * ```typescript
+     * const { contradictions, total } = await client.research.getContradictions('session-uuid');
+     * for (const c of contradictions) {
+     *   console.log(`Contradiction (confidence: ${c.confidence}):`);
+     *   console.log(`  A: ${c.statementA}`);
+     *   console.log(`  B: ${c.statementB}`);
+     *   console.log(`  Explanation: ${c.explanation}`);
+     * }
+     * ```
+     */
+    getContradictions(sessionId: string): Promise<ResearchContradictionsResponse>;
+    /**
+     * Get the full research report for a session.
+     *
+     * @param sessionId - The session ID (UUID).
+     * @returns Complete report with findings, gaps, contradictions, statistics, and verification.
+     * @throws {ApiError} If the session does not exist or the request fails.
+     *
+     * @remarks
+     * Generates and returns a comprehensive research report including the
+     * executive summary, all verified findings, unresolved knowledge gaps,
+     * detected contradictions, research statistics, and an optional
+     * FormalJudge verification result.
+     *
+     * @example
+     * ```typescript
+     * const report = await client.research.getReport('session-uuid');
+     * console.log(report.summary);
+     * console.log(`Findings: ${report.findings.length}`);
+     * console.log(`Gaps: ${report.knowledgeGaps.length}`);
+     * console.log(`Contradictions: ${report.contradictions.length}`);
+     * if (report.verification) {
+     *   console.log(`Verdict: ${report.verification.verdict} (${report.verification.score})`);
+     * }
+     * ```
+     */
+    getReport(sessionId: string): Promise<ResearchReportResponse>;
+    /**
+     * Search for papers across external scientific databases.
+     *
+     * @param request - Search parameters including query, max results, and source filters.
+     * @returns Search results with paper metadata and relevance scores.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Queries external paper databases (PubMed, Semantic Scholar, CrossRef, arXiv)
+     * and returns unified results with relevance scores. Results are not
+     * automatically ingested — use {@link ingestPaper} to add specific papers
+     * to the knowledge base.
+     *
+     * @example
+     * ```typescript
+     * const { results, totalFound } = await client.research.searchPapers({
+     *   query: 'CRISPR gene editing efficiency',
+     *   maxResults: 20,
+     *   sources: ['PubMed', 'SemanticScholar'],
+     * });
+     * console.log(`Found ${totalFound} papers, returning ${results.length}`);
+     * for (const r of results) {
+     *   console.log(`${r.metadata.title} (${r.metadata.year}) — score: ${r.relevanceScore}`);
+     * }
+     * ```
+     */
+    searchPapers(request: SearchPapersRequest): Promise<SearchPapersResponse>;
+    /**
+     * Ingest a specific paper into the knowledge base.
+     *
+     * @param request - Paper identifier and type, with optional session association.
+     * @returns Ingestion result with metadata and extraction counts.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Retrieves the paper by its identifier (DOI, PMID, arXiv ID, or URL),
+     * extracts entities and claims, and ingests them into the OSFKB. If a
+     * session ID is provided, the ingested data is associated with that
+     * research session.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.research.ingestPaper({
+     *   identifier: '10.1038/s41586-023-06004-9',
+     *   identifierType: 'doi',
+     *   sessionId: 'session-uuid',
+     * });
+     * if (result.success) {
+     *   console.log(`Extracted ${result.entitiesExtracted} entities`);
+     *   console.log(`Extracted ${result.claimsExtracted} claims`);
+     * }
+     * ```
+     */
+    ingestPaper(request: IngestPaperRequest): Promise<IngestPaperResponse>;
+    /**
+     * Verify a specific claim against evidence in the knowledge base.
+     *
+     * @param request - Claim term ID and evidence sort ID.
+     * @returns Verification result with truthfulness score and evidence counts.
+     * @throws {ApiError} If the request fails.
+     *
+     * @remarks
+     * Runs evidence assessment on a single claim by collecting all evidence
+     * of the specified sort and computing a truthfulness score. The result
+     * includes the assessment label, counts of supporting/contradicting
+     * evidence, and residuation status if insufficient evidence exists.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.research.verifyClaim({
+     *   claimTermId: 'claim-term-uuid',
+     *   evidenceSortId: 'evidence-sort-uuid',
+     * });
+     * console.log(`Truthfulness: ${result.truthfulness}`);
+     * console.log(`Label: ${result.label}`);
+     * console.log(`Supporting: ${result.supportingCount}, Contradicting: ${result.contradictingCount}`);
+     * if (result.residuated) {
+     *   console.log(`Residuated: ${result.residuationReason}`);
+     * }
+     * ```
+     */
+    verifyClaim(request: VerifyClaimRequest): Promise<VerifyClaimResponse>;
+}
+
 /** Core knowledge base operations — types, records, rules, functions, constraints, and queries. */
 interface CoreGroup {
     readonly types: SortsClient;
@@ -37477,6 +38427,8 @@ declare class ReasoningLayerClient {
     readonly osfql: OsfqlClient;
     /** Conversational AI operations (NL → OSFQL with self-correction). */
     readonly conversation: ConversationClient;
+    /** Verified scientific research pipeline operations. */
+    readonly research: ResearchClient;
     private _core?;
     private _ai?;
     private _reasoning?;
@@ -37856,6 +38808,253 @@ declare const FuzzyShape: {
      * ```
      */
     readonly cyclicGaussian: (mean: number, stdDev: number, period: number) => CyclicGaussianShape;
+    /**
+     * Create a sigmoid (logistic) fuzzy membership function.
+     *
+     * Monotonic S-curve transition: `μ(x) = 1 / (1 + exp(-steepness * (x - midpoint)))`.
+     * Positive steepness = increasing, negative = decreasing.
+     *
+     * @param midpoint - The x-value where membership = 0.5 (inflection point).
+     * @param steepness - Controls transition sharpness. Positive = left-to-right rise.
+     * @returns A `SigmoidShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * // DNA match confidence: sharp transition around 95%
+     * FuzzyShape.sigmoid(0.95, 20)
+     * // {"kind": "Sigmoid", "midpoint": 0.95, "steepness": 20}
+     * ```
+     */
+    readonly sigmoid: (midpoint: number, steepness: number) => SigmoidShape;
+    /**
+     * Create a generalized bell fuzzy membership function.
+     *
+     * Tunable flat-top bell: `μ(x) = 1 / (1 + |((x - center) / width)|^(2*slope))`.
+     * Unlike Gaussian, the slope controls how sharply the curve drops off.
+     *
+     * @param center - Center of the bell (membership = 1).
+     * @param width - Half-width of the bell at the crossover point.
+     * @param slope - Controls steepness of the sides. Higher = sharper edges.
+     * @returns A `BellShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.bell(100, 15, 3)
+     * // {"kind": "Bell", "center": 100, "width": 15, "slope": 3}
+     * ```
+     */
+    readonly bell: (center: number, width: number, slope: number) => BellShape;
+    /**
+     * Create a sigmoid difference fuzzy membership function.
+     *
+     * Difference of two sigmoids: creates a smooth bounded region (like a smooth trapezoidal).
+     * `μ(x) = sigmoid(x, midpoint1, steepness1) - sigmoid(x, midpoint2, steepness2)`.
+     *
+     * @param midpoint1 - Left transition inflection point.
+     * @param steepness1 - Left transition sharpness (positive = rising).
+     * @param midpoint2 - Right transition inflection point.
+     * @param steepness2 - Right transition sharpness (positive = falling).
+     * @returns A `SigmoidDifferenceShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * // Smooth region between pH 6.5 and 7.5
+     * FuzzyShape.sigmoidDifference(6.5, 10, 7.5, 10)
+     * // {"kind": "SigmoidDifference", "midpoint1": 6.5, "steepness1": 10, "midpoint2": 7.5, "steepness2": 10}
+     * ```
+     */
+    readonly sigmoidDifference: (midpoint1: number, steepness1: number, midpoint2: number, steepness2: number) => SigmoidDifferenceShape;
+    /**
+     * Create a Gaussian product (gauss2mf) fuzzy membership function.
+     *
+     * Asymmetric flat-top bell: left Gaussian up to mean1, flat 1.0 in [mean1, mean2],
+     * right Gaussian after mean2.
+     *
+     * @param mean1 - Left Gaussian center.
+     * @param stdDev1 - Left Gaussian standard deviation.
+     * @param mean2 - Right Gaussian center.
+     * @param stdDev2 - Right Gaussian standard deviation.
+     * @returns A `GaussianProductShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.gaussianProduct(36.5, 0.3, 37.5, 0.2)
+     * // {"kind": "GaussianProduct", "mean1": 36.5, "stdDev1": 0.3, "mean2": 37.5, "stdDev2": 0.2}
+     * ```
+     */
+    readonly gaussianProduct: (mean1: number, stdDev1: number, mean2: number, stdDev2: number) => GaussianProductShape;
+    /**
+     * Create a sigmoid product fuzzy membership function.
+     *
+     * Product of two sigmoids: `μ(x) = sigmoid(x, midpoint1, steepness1) * sigmoid(x, midpoint2, steepness2)`.
+     * Always non-negative (unlike {@link sigmoidDifference}).
+     *
+     * @param midpoint1 - First sigmoid inflection point.
+     * @param steepness1 - First sigmoid sharpness.
+     * @param midpoint2 - Second sigmoid inflection point.
+     * @param steepness2 - Second sigmoid sharpness.
+     * @returns A `SigmoidProductShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.sigmoidProduct(6.5, 10, 7.5, -10)
+     * // {"kind": "SigmoidProduct", "midpoint1": 6.5, "steepness1": 10, "midpoint2": 7.5, "steepness2": -10}
+     * ```
+     */
+    readonly sigmoidProduct: (midpoint1: number, steepness1: number, midpoint2: number, steepness2: number) => SigmoidProductShape;
+    /**
+     * Create a cosine fuzzy membership function with compact support.
+     *
+     * `μ(x) = 0.5 * (1 + cos(2π/width * (x - center)))` for `|x - center| <= width/2`,
+     * `μ(x) = 0` otherwise.
+     *
+     * @param center - Center of the cosine curve (membership = 1).
+     * @param width - Full width of the support region.
+     * @returns A `CosineShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.cosine(50, 10)
+     * // {"kind": "Cosine", "center": 50, "width": 10}
+     * ```
+     */
+    readonly cosine: (center: number, width: number) => CosineShape;
+    /**
+     * Create a spike (Laplacian/double-exponential) fuzzy membership function.
+     *
+     * `μ(x) = exp(-|x - center| / width)`. Sharp cusp at center with exponential tails.
+     *
+     * @param center - Peak of the spike (membership = 1).
+     * @param width - Controls the rate of exponential decay.
+     * @returns A `SpikeShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.spike(100, 5)
+     * // {"kind": "Spike", "center": 100, "width": 5}
+     * ```
+     */
+    readonly spike: (center: number, width: number) => SpikeShape;
+    /**
+     * Create a Cauchy (Lorentzian) fuzzy membership function.
+     *
+     * `μ(x) = 1 / (1 + ((x - center) / gamma)^2)`. Heavy-tailed bell whose tails never reach zero.
+     *
+     * @param center - Center of the Cauchy curve (membership = 1).
+     * @param gamma - Half-width at half-maximum, controlling the spread.
+     * @returns A `CauchyShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.cauchy(0, 1)
+     * // {"kind": "Cauchy", "center": 0, "gamma": 1}
+     * ```
+     */
+    readonly cauchy: (center: number, gamma: number) => CauchyShape;
+    /**
+     * Create an S-shaped (smf) fuzzy membership function.
+     *
+     * Smooth monotonic spline from 0 to 1 using piecewise quadratic.
+     * Reaches exact 0 and 1 (unlike {@link sigmoid}).
+     *
+     * @param a - Foot: x-value where membership starts rising from 0.
+     * @param b - Shoulder: x-value where membership reaches 1.
+     * @returns An `SShapeShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.sShape(20, 80)
+     * // {"kind": "SShape", "a": 20, "b": 80}
+     * ```
+     */
+    readonly sShape: (a: number, b: number) => SShapeShape;
+    /**
+     * Create a Z-shaped (zmf) fuzzy membership function.
+     *
+     * Mirror of {@link sShape}. Smooth monotonic spline from 1 to 0
+     * using piecewise quadratic.
+     *
+     * @param a - Shoulder: x-value where membership starts falling from 1.
+     * @param b - Foot: x-value where membership reaches 0.
+     * @returns A `ZShapeShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.zShape(20, 80)
+     * // {"kind": "ZShape", "a": 20, "b": 80}
+     * ```
+     */
+    readonly zShape: (a: number, b: number) => ZShapeShape;
+    /**
+     * Create a Pi-shaped (pimf) fuzzy membership function.
+     *
+     * Smooth flat-top bump: `μ(x) = SShape(x, a, b) * ZShape(x, c, d)`.
+     * Like a smooth trapezoidal.
+     *
+     * @param a - Left foot (SShape start).
+     * @param b - Left shoulder (SShape end).
+     * @param c - Right shoulder (ZShape start).
+     * @param d - Right foot (ZShape end).
+     * @returns A `PiShapeShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.piShape(10, 20, 60, 80)
+     * // {"kind": "PiShape", "a": 10, "b": 20, "c": 60, "d": 80}
+     * ```
+     */
+    readonly piShape: (a: number, b: number, c: number, d: number) => PiShapeShape;
+    /**
+     * Create a piecewise linear fuzzy membership function.
+     *
+     * Membership is linearly interpolated between the provided (x, mu) data points.
+     *
+     * @param points - Array of `[x, mu]` tuples defining the membership function.
+     * @returns A `PiecewiseLinearShape`.
+     *
+     * @remarks
+     * Serialization format: Tagged by `"kind"` (FuzzyShapeDto).
+     *
+     * @example
+     * ```typescript
+     * FuzzyShape.piecewiseLinear([[0, 0], [0.5, 1], [1, 0]])
+     * // {"kind": "PiecewiseLinear", "points": [[0, 0], [0.5, 1], [1, 0]]}
+     * ```
+     */
+    readonly piecewiseLinear: (points: [number, number][]) => PiecewiseLinearShape;
 };
 
 /**
@@ -38457,4 +39656,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 CreateSortRequest, type CreateTermRequest, type DataGroup, discovery as Discovery, type 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, ingestion as Ingestion, 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 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, reviews as Reviews, row as Row, SDK_VERSION, scenarios as Scenarios, 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, 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, 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, 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 };