@lucern/sdk 1.0.11 → 1.0.12

package/dist/contracts/lens-filter.contract.d.ts

@@ -21,7 +21,7 @@
  *
  * V2 will add `propertyMatchers` here for arbitrary JSON Schema facet queries.
  */
-type EntityTypeFilterV1 = {
+export type EntityTypeFilterV1 = {
     /** References ontologyVersion.entityTypes[].value, e.g. "company" */
     entityTypeValue: string;
     /** Optional subtype narrowing. If omitted or empty, all subtypes match. */
@@ -31,14 +31,14 @@ type EntityTypeFilterV1 = {
  * Optional scope to restrict which ontology the filter resolves against.
  * If omitted, resolution uses whatever ontology is active in the workspace.
  */
-type OntologyScope = {
+export type OntologyScope = {
     /** Restrict to a specific ontology by key, e.g. "vc-investment" */
     ontologyKey?: string;
 };
 /**
  * Taxonomy filter criteria v1: entity type + subtype matching over ontology.
  */
-type TaxonomyFilterCriteriaV1 = {
+export type TaxonomyFilterCriteriaV1 = {
     version: 1;
     kind: "taxonomy";
     entityTypeFilters: EntityTypeFilterV1[];
@@ -54,10 +54,10 @@ type TaxonomyFilterCriteriaV1 = {
  *   3. Add a resolver in taxonomy-filter.ts
  *   4. No schema migration needed — filterCriteria is v.any()
  */
-type LensFilterCriteria = TaxonomyFilterCriteriaV1;
-declare function isLensFilterCriteria(value: unknown): value is LensFilterCriteria;
-declare function isTaxonomyFilterCriteriaV1(value: unknown): value is TaxonomyFilterCriteriaV1;
-type FilterValidationResult = {
+export type LensFilterCriteria = TaxonomyFilterCriteriaV1;
+export declare function isLensFilterCriteria(value: unknown): value is LensFilterCriteria;
+export declare function isTaxonomyFilterCriteriaV1(value: unknown): value is TaxonomyFilterCriteriaV1;
+export type FilterValidationResult = {
     valid: true;
 } | {
     valid: false;
@@ -67,6 +67,5 @@ type FilterValidationResult = {
  * Validate a filter criteria document at the contract layer.
  * This runs before persisting to Convex.
  */
-declare function validateFilterCriteria(value: unknown): FilterValidationResult;
-
-export { type EntityTypeFilterV1, type FilterValidationResult, type LensFilterCriteria, type OntologyScope, type TaxonomyFilterCriteriaV1, isLensFilterCriteria, isTaxonomyFilterCriteriaV1, validateFilterCriteria };
+export declare function validateFilterCriteria(value: unknown): FilterValidationResult;
+//# sourceMappingURL=lens-filter.contract.d.ts.map

package/dist/contracts/lens-filter.contract.js

@@ -1,72 +1,96 @@
-// src/contracts/lens-filter.contract.ts
-function isLensFilterCriteria(value) {
-  return isRecord(value) && typeof value.version === "number" && typeof value.kind === "string";
+/**
+ * Lens Filter Criteria Contract
+ *
+ * Version-discriminated filter DSL for lenses. Each filter criteria document
+ * carries a `version` and `kind` discriminator so future shapes can coexist
+ * without schema migrations. The Convex `filterCriteria` field remains v.any()
+ * — all type enforcement happens here at the TypeScript contract layer.
+ *
+ * Forward-compatibility guarantees:
+ * - `version` field: new versions add fields, never remove or rename existing ones
+ * - `kind` field: new filter kinds (temporal, confidence-range) can be added
+ *   without touching taxonomy code paths
+ * - `entityTypeFilters` array items are open to extension in future versions
+ * - Resolution logic switches on `version` + `kind` to select the right resolver
+ *
+ * @module lucern/contracts/src/lens-filter
+ */
+// Future: | TemporalFilterCriteriaV1 | ConfidenceRangeFilterCriteriaV1 | ...
+// ---------------------------------------------------------------------------
+// Type guards
+// ---------------------------------------------------------------------------
+export function isLensFilterCriteria(value) {
+    return isRecord(value) && typeof value.version === "number" && typeof value.kind === "string";
 }
-function isTaxonomyFilterCriteriaV1(value) {
-  if (!isLensFilterCriteria(value)) return false;
-  return value.version === 1 && value.kind === "taxonomy";
+export function isTaxonomyFilterCriteriaV1(value) {
+    if (!isLensFilterCriteria(value))
+        return false;
+    return value.version === 1 && value.kind === "taxonomy";
 }
-function validateFilterCriteria(value) {
-  if (value === void 0 || value === null) {
-    return { valid: true };
-  }
-  if (!isLensFilterCriteria(value)) {
+/**
+ * Validate a filter criteria document at the contract layer.
+ * This runs before persisting to Convex.
+ */
+export function validateFilterCriteria(value) {
+    if (value === undefined || value === null) {
+        return { valid: true }; // filterCriteria is optional
+    }
+    if (!isLensFilterCriteria(value)) {
+        return {
+            valid: false,
+            errors: [
+                'filterCriteria must have numeric "version" and string "kind" fields',
+            ],
+        };
+    }
+    if (isTaxonomyFilterCriteriaV1(value)) {
+        return validateTaxonomyFilterV1(value);
+    }
+    // Cast to access properties — TypeScript narrows to `never` when all union
+    // members are exhausted, but at runtime unknown version/kind combos are possible.
+    const raw = value;
     return {
-      valid: false,
-      errors: [
-        'filterCriteria must have numeric "version" and string "kind" fields'
-      ]
+        valid: false,
+        errors: [
+            `Unsupported filter criteria: version=${raw.version}, kind=${raw.kind}`,
+        ],
     };
-  }
-  if (isTaxonomyFilterCriteriaV1(value)) {
-    return validateTaxonomyFilterV1(value);
-  }
-  const raw = value;
-  return {
-    valid: false,
-    errors: [
-      `Unsupported filter criteria: version=${raw.version}, kind=${raw.kind}`
-    ]
-  };
 }
 function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+    return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function validateTaxonomyFilterV1(criteria) {
-  const errors = [];
-  if (!Array.isArray(criteria.entityTypeFilters)) {
-    errors.push("entityTypeFilters must be an array");
-    return { valid: false, errors };
-  }
-  if (criteria.entityTypeFilters.length === 0) {
-    errors.push("entityTypeFilters must contain at least one entry");
-    return { valid: false, errors };
-  }
-  for (let i = 0; i < criteria.entityTypeFilters.length; i++) {
-    const filter = criteria.entityTypeFilters[i];
-    if (!filter || typeof filter.entityTypeValue !== "string") {
-      errors.push(
-        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
-      );
-      continue;
+    const errors = [];
+    if (!Array.isArray(criteria.entityTypeFilters)) {
+        errors.push("entityTypeFilters must be an array");
+        return { valid: false, errors };
     }
-    if (filter.entityTypeValue.trim().length === 0) {
-      errors.push(
-        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
-      );
+    if (criteria.entityTypeFilters.length === 0) {
+        errors.push("entityTypeFilters must contain at least one entry");
+        return { valid: false, errors };
     }
-    if (filter.subtypeValues !== void 0 && !Array.isArray(filter.subtypeValues)) {
-      errors.push(`entityTypeFilters[${i}].subtypeValues must be an array`);
+    for (let i = 0; i < criteria.entityTypeFilters.length; i++) {
+        const filter = criteria.entityTypeFilters[i];
+        if (!filter || typeof filter.entityTypeValue !== "string") {
+            errors.push(`entityTypeFilters[${i}].entityTypeValue must be a non-empty string`);
+            continue;
+        }
+        if (filter.entityTypeValue.trim().length === 0) {
+            errors.push(`entityTypeFilters[${i}].entityTypeValue must be a non-empty string`);
+        }
+        if (filter.subtypeValues !== undefined &&
+            !Array.isArray(filter.subtypeValues)) {
+            errors.push(`entityTypeFilters[${i}].subtypeValues must be an array`);
+        }
     }
-  }
-  if (criteria.ontologyScope !== void 0) {
-    if (typeof criteria.ontologyScope !== "object" || criteria.ontologyScope === null) {
-      errors.push("ontologyScope must be an object");
+    if (criteria.ontologyScope !== undefined) {
+        if (typeof criteria.ontologyScope !== "object" ||
+            criteria.ontologyScope === null) {
+            errors.push("ontologyScope must be an object");
+        }
     }
-  }
-  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+    return errors.length === 0
+        ? { valid: true }
+        : { valid: false, errors };
 }
-
-export { isLensFilterCriteria, isTaxonomyFilterCriteriaV1, validateFilterCriteria };
-//# sourceMappingURL=lens-filter.contract.js.map
 //# sourceMappingURL=lens-filter.contract.js.map

package/dist/contracts/lens-workflow.contract.d.ts

@@ -1,17 +1,16 @@
-export { EntityTypeFilterV1, FilterValidationResult, LensFilterCriteria, OntologyScope, TaxonomyFilterCriteriaV1, isLensFilterCriteria, isTaxonomyFilterCriteriaV1, validateFilterCriteria } from './lens-filter.contract.js';
-
 /**
  * Canonical lens workflow contract shared across schema, SDK, and MCP surfaces.
  */
-
-declare const LENS_PERSPECTIVE_TYPES: readonly ["investigation", "monitoring", "analysis", "comparison", "taxonomy"];
-type LensPerspectiveType = (typeof LENS_PERSPECTIVE_TYPES)[number];
-declare const LENS_STATUSES: readonly ["draft", "active", "archived"];
-type LensStatus = (typeof LENS_STATUSES)[number];
-declare const LENS_TASK_TEMPLATE_PRIORITIES: readonly ["critical", "high", "medium", "low"];
-type LensTaskTemplatePriority = (typeof LENS_TASK_TEMPLATE_PRIORITIES)[number];
-type LensLooseMetadata = Record<string, unknown>;
-type LensPromptTemplateReference = {
+export type { LensFilterCriteria, TaxonomyFilterCriteriaV1, EntityTypeFilterV1, OntologyScope, FilterValidationResult, } from "./lens-filter.contract";
+export { validateFilterCriteria, isLensFilterCriteria, isTaxonomyFilterCriteriaV1, } from "./lens-filter.contract";
+export declare const LENS_PERSPECTIVE_TYPES: readonly ["investigation", "monitoring", "analysis", "comparison", "taxonomy"];
+export type LensPerspectiveType = (typeof LENS_PERSPECTIVE_TYPES)[number];
+export declare const LENS_STATUSES: readonly ["draft", "active", "archived"];
+export type LensStatus = (typeof LENS_STATUSES)[number];
+export declare const LENS_TASK_TEMPLATE_PRIORITIES: readonly ["critical", "high", "medium", "low"];
+export type LensTaskTemplatePriority = (typeof LENS_TASK_TEMPLATE_PRIORITIES)[number];
+export type LensLooseMetadata = Record<string, unknown>;
+export type LensPromptTemplateReference = {
     key: string;
     promptRef: string;
     phase?: string;
@@ -20,7 +19,7 @@ type LensPromptTemplateReference = {
     required?: boolean;
     metadata?: LensLooseMetadata;
 };
-type LensWorkflowStepTemplate = {
+export type LensWorkflowStepTemplate = {
     key: string;
     title: string;
     description?: string;
@@ -28,14 +27,14 @@ type LensWorkflowStepTemplate = {
     taskTemplateKeys?: string[];
     metadata?: LensLooseMetadata;
 };
-type LensWorkflowTemplate = {
+export type LensWorkflowTemplate = {
     key: string;
     name: string;
     description?: string;
     steps: LensWorkflowStepTemplate[];
     metadata?: LensLooseMetadata;
 };
-type LensTaskTemplate = {
+export type LensTaskTemplate = {
     key: string;
     title: string;
     description?: string;
@@ -43,14 +42,14 @@ type LensTaskTemplate = {
     phase?: string;
     metadata?: LensLooseMetadata;
 };
-type LensQuestionTemplate = {
+export type LensQuestionTemplate = {
     key: string;
     text: string;
     priority?: LensTaskTemplatePriority;
     linkedBeliefKey?: string;
     metadata?: LensLooseMetadata;
 };
-type LensBranchMigrationSuggestion = {
+export type LensBranchMigrationSuggestion = {
     recommendedTool: "create_lens";
     perspectiveType: LensPerspectiveType;
     message: string;
@@ -62,26 +61,25 @@ type LensBranchMigrationSuggestion = {
         perspectiveType: LensPerspectiveType;
     };
 };
-declare const BRANCH_DEPRECATION_MESSAGE = "Branches are deprecated for operational framing. Create a workspace-scoped lens instead.";
-type DeprecatedBranchMetadata = {
+export declare const BRANCH_DEPRECATION_MESSAGE = "Branches are deprecated for operational framing. Create a workspace-scoped lens instead.";
+export type DeprecatedBranchMetadata = {
     deprecated: true;
     deprecationMessage: string;
     lensSuggestion: LensBranchMigrationSuggestion;
 };
-declare function inferLensPerspectiveTypeFromBranchSchema(schema?: string | null): LensPerspectiveType;
-declare function migrateBranchToLens(args: {
+export declare function inferLensPerspectiveTypeFromBranchSchema(schema?: string | null): LensPerspectiveType;
+export declare function migrateBranchToLens(args: {
     name: string;
     description?: string;
     topicId?: string;
     workspaceId?: string;
     schema?: string | null;
 }): LensBranchMigrationSuggestion;
-declare function buildDeprecatedBranchMetadata(args: {
+export declare function buildDeprecatedBranchMetadata(args: {
     name: string;
     description?: string;
     topicId?: string;
     workspaceId?: string;
     schema?: string | null;
 }): DeprecatedBranchMetadata;
-
-export { BRANCH_DEPRECATION_MESSAGE, type DeprecatedBranchMetadata, LENS_PERSPECTIVE_TYPES, LENS_STATUSES, LENS_TASK_TEMPLATE_PRIORITIES, type LensBranchMigrationSuggestion, type LensLooseMetadata, type LensPerspectiveType, type LensPromptTemplateReference, type LensQuestionTemplate, type LensStatus, type LensTaskTemplate, type LensTaskTemplatePriority, type LensWorkflowStepTemplate, type LensWorkflowTemplate, buildDeprecatedBranchMetadata, inferLensPerspectiveTypeFromBranchSchema, migrateBranchToLens };
+//# sourceMappingURL=lens-workflow.contract.d.ts.map

package/dist/contracts/lens-workflow.contract.js

@@ -1,124 +1,55 @@
-// src/contracts/lens-filter.contract.ts
-function isLensFilterCriteria(value) {
-  return isRecord(value) && typeof value.version === "number" && typeof value.kind === "string";
-}
-function isTaxonomyFilterCriteriaV1(value) {
-  if (!isLensFilterCriteria(value)) return false;
-  return value.version === 1 && value.kind === "taxonomy";
-}
-function validateFilterCriteria(value) {
-  if (value === void 0 || value === null) {
-    return { valid: true };
-  }
-  if (!isLensFilterCriteria(value)) {
-    return {
-      valid: false,
-      errors: [
-        'filterCriteria must have numeric "version" and string "kind" fields'
-      ]
-    };
-  }
-  if (isTaxonomyFilterCriteriaV1(value)) {
-    return validateTaxonomyFilterV1(value);
-  }
-  const raw = value;
-  return {
-    valid: false,
-    errors: [
-      `Unsupported filter criteria: version=${raw.version}, kind=${raw.kind}`
-    ]
-  };
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function validateTaxonomyFilterV1(criteria) {
-  const errors = [];
-  if (!Array.isArray(criteria.entityTypeFilters)) {
-    errors.push("entityTypeFilters must be an array");
-    return { valid: false, errors };
-  }
-  if (criteria.entityTypeFilters.length === 0) {
-    errors.push("entityTypeFilters must contain at least one entry");
-    return { valid: false, errors };
-  }
-  for (let i = 0; i < criteria.entityTypeFilters.length; i++) {
-    const filter = criteria.entityTypeFilters[i];
-    if (!filter || typeof filter.entityTypeValue !== "string") {
-      errors.push(
-        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
-      );
-      continue;
-    }
-    if (filter.entityTypeValue.trim().length === 0) {
-      errors.push(
-        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
-      );
+/**
+ * Canonical lens workflow contract shared across schema, SDK, and MCP surfaces.
+ */
+export { validateFilterCriteria, isLensFilterCriteria, isTaxonomyFilterCriteriaV1, } from "./lens-filter.contract.js";
+export const LENS_PERSPECTIVE_TYPES = [
+    "investigation",
+    "monitoring",
+    "analysis",
+    "comparison",
+    "taxonomy",
+];
+export const LENS_STATUSES = ["draft", "active", "archived"];
+export const LENS_TASK_TEMPLATE_PRIORITIES = [
+    "critical",
+    "high",
+    "medium",
+    "low",
+];
+export const BRANCH_DEPRECATION_MESSAGE = "Branches are deprecated for operational framing. Create a workspace-scoped lens instead.";
+export function inferLensPerspectiveTypeFromBranchSchema(schema) {
+    const normalized = schema?.trim().toLowerCase();
+    if (normalized === "phase") {
+        return "monitoring";
     }
-    if (filter.subtypeValues !== void 0 && !Array.isArray(filter.subtypeValues)) {
-      errors.push(`entityTypeFilters[${i}].subtypeValues must be an array`);
+    if (normalized === "axis" || normalized === "dimension") {
+        return "comparison";
     }
-  }
-  if (criteria.ontologyScope !== void 0) {
-    if (typeof criteria.ontologyScope !== "object" || criteria.ontologyScope === null) {
-      errors.push("ontologyScope must be an object");
+    if (normalized === "track") {
+        return "investigation";
     }
-  }
-  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+    return "analysis";
 }
-
-// src/contracts/lens-workflow.contract.ts
-var LENS_PERSPECTIVE_TYPES = [
-  "investigation",
-  "monitoring",
-  "analysis",
-  "comparison",
-  "taxonomy"
-];
-var LENS_STATUSES = ["draft", "active", "archived"];
-var LENS_TASK_TEMPLATE_PRIORITIES = [
-  "critical",
-  "high",
-  "medium",
-  "low"
-];
-var BRANCH_DEPRECATION_MESSAGE = "Branches are deprecated for operational framing. Create a workspace-scoped lens instead.";
-function inferLensPerspectiveTypeFromBranchSchema(schema) {
-  const normalized = schema?.trim().toLowerCase();
-  if (normalized === "phase") {
-    return "monitoring";
-  }
-  if (normalized === "axis" || normalized === "dimension") {
-    return "comparison";
-  }
-  if (normalized === "track") {
-    return "investigation";
-  }
-  return "analysis";
-}
-function migrateBranchToLens(args) {
-  const perspectiveType = inferLensPerspectiveTypeFromBranchSchema(args.schema);
-  return {
-    recommendedTool: "create_lens",
-    perspectiveType,
-    message: "Branches are deprecated for operational framing. Create a workspace-scoped lens with the suggested payload instead.",
-    suggestedPayload: {
-      name: args.name,
-      description: args.description,
-      topicId: args.topicId,
-      workspaceId: args.workspaceId,
-      perspectiveType
-    }
-  };
+export function migrateBranchToLens(args) {
+    const perspectiveType = inferLensPerspectiveTypeFromBranchSchema(args.schema);
+    return {
+        recommendedTool: "create_lens",
+        perspectiveType,
+        message: "Branches are deprecated for operational framing. Create a workspace-scoped lens with the suggested payload instead.",
+        suggestedPayload: {
+            name: args.name,
+            description: args.description,
+            topicId: args.topicId,
+            workspaceId: args.workspaceId,
+            perspectiveType,
+        },
+    };
 }
-function buildDeprecatedBranchMetadata(args) {
-  return {
-    deprecated: true,
-    deprecationMessage: BRANCH_DEPRECATION_MESSAGE,
-    lensSuggestion: migrateBranchToLens(args)
-  };
+export function buildDeprecatedBranchMetadata(args) {
+    return {
+        deprecated: true,
+        deprecationMessage: BRANCH_DEPRECATION_MESSAGE,
+        lensSuggestion: migrateBranchToLens(args),
+    };
 }
-
-export { BRANCH_DEPRECATION_MESSAGE, LENS_PERSPECTIVE_TYPES, LENS_STATUSES, LENS_TASK_TEMPLATE_PRIORITIES, buildDeprecatedBranchMetadata, inferLensPerspectiveTypeFromBranchSchema, isLensFilterCriteria, isTaxonomyFilterCriteriaV1, migrateBranchToLens, validateFilterCriteria };
-//# sourceMappingURL=lens-workflow.contract.js.map
 //# sourceMappingURL=lens-workflow.contract.js.map

package/dist/contracts/lensFilter.d.ts

@@ -1 +1,2 @@
-export { EntityTypeFilterV1, FilterValidationResult, LensFilterCriteria, OntologyScope, TaxonomyFilterCriteriaV1, isLensFilterCriteria, isTaxonomyFilterCriteriaV1, validateFilterCriteria } from './lens-filter.contract.js';
+export * from "./lens-filter.contract";
+//# sourceMappingURL=lensFilter.d.ts.map

package/dist/contracts/lensFilter.js

@@ -1,72 +1,2 @@
-// src/contracts/lens-filter.contract.ts
-function isLensFilterCriteria(value) {
-  return isRecord(value) && typeof value.version === "number" && typeof value.kind === "string";
-}
-function isTaxonomyFilterCriteriaV1(value) {
-  if (!isLensFilterCriteria(value)) return false;
-  return value.version === 1 && value.kind === "taxonomy";
-}
-function validateFilterCriteria(value) {
-  if (value === void 0 || value === null) {
-    return { valid: true };
-  }
-  if (!isLensFilterCriteria(value)) {
-    return {
-      valid: false,
-      errors: [
-        'filterCriteria must have numeric "version" and string "kind" fields'
-      ]
-    };
-  }
-  if (isTaxonomyFilterCriteriaV1(value)) {
-    return validateTaxonomyFilterV1(value);
-  }
-  const raw = value;
-  return {
-    valid: false,
-    errors: [
-      `Unsupported filter criteria: version=${raw.version}, kind=${raw.kind}`
-    ]
-  };
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function validateTaxonomyFilterV1(criteria) {
-  const errors = [];
-  if (!Array.isArray(criteria.entityTypeFilters)) {
-    errors.push("entityTypeFilters must be an array");
-    return { valid: false, errors };
-  }
-  if (criteria.entityTypeFilters.length === 0) {
-    errors.push("entityTypeFilters must contain at least one entry");
-    return { valid: false, errors };
-  }
-  for (let i = 0; i < criteria.entityTypeFilters.length; i++) {
-    const filter = criteria.entityTypeFilters[i];
-    if (!filter || typeof filter.entityTypeValue !== "string") {
-      errors.push(
-        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
-      );
-      continue;
-    }
-    if (filter.entityTypeValue.trim().length === 0) {
-      errors.push(
-        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
-      );
-    }
-    if (filter.subtypeValues !== void 0 && !Array.isArray(filter.subtypeValues)) {
-      errors.push(`entityTypeFilters[${i}].subtypeValues must be an array`);
-    }
-  }
-  if (criteria.ontologyScope !== void 0) {
-    if (typeof criteria.ontologyScope !== "object" || criteria.ontologyScope === null) {
-      errors.push("ontologyScope must be an object");
-    }
-  }
-  return errors.length === 0 ? { valid: true } : { valid: false, errors };
-}
-
-export { isLensFilterCriteria, isTaxonomyFilterCriteriaV1, validateFilterCriteria };
-//# sourceMappingURL=lensFilter.js.map
+export * from "./lens-filter.contract.js";
 //# sourceMappingURL=lensFilter.js.map

package/dist/contracts/lensWorkflow.d.ts

@@ -1,2 +1,2 @@
-export { BRANCH_DEPRECATION_MESSAGE, DeprecatedBranchMetadata, LENS_PERSPECTIVE_TYPES, LENS_STATUSES, LENS_TASK_TEMPLATE_PRIORITIES, LensBranchMigrationSuggestion, LensLooseMetadata, LensPerspectiveType, LensPromptTemplateReference, LensQuestionTemplate, LensStatus, LensTaskTemplate, LensTaskTemplatePriority, LensWorkflowStepTemplate, LensWorkflowTemplate, buildDeprecatedBranchMetadata, inferLensPerspectiveTypeFromBranchSchema, migrateBranchToLens } from './lens-workflow.contract.js';
-export { EntityTypeFilterV1, FilterValidationResult, LensFilterCriteria, OntologyScope, TaxonomyFilterCriteriaV1, isLensFilterCriteria, isTaxonomyFilterCriteriaV1, validateFilterCriteria } from './lens-filter.contract.js';
+export * from "./lens-workflow.contract";
+//# sourceMappingURL=lensWorkflow.d.ts.map