@contractspec/module.workspace 0.0.0-canary-20260113162409

package/dist/types/generation-types.d.ts

@@ -0,0 +1,87 @@
+import { PresentationKind, SpecType } from "./spec-types.js";
+import { RuleSyncConfig } from "./rulesync-types.js";
+import { OpKind } from "@contractspec/lib.contracts";
+
+//#region src/types/generation-types.d.ts
+
+/**
+ * AI provider options for generation.
+ */
+interface AIGenerationOptions {
+  provider: 'claude' | 'openai' | 'ollama' | 'custom';
+  model?: string;
+  endpoint?: string;
+  stream?: boolean;
+}
+/**
+ * Result of code generation.
+ */
+interface GenerationResult {
+  code: string;
+  filePath: string;
+  specType: SpecType;
+}
+/**
+ * Build target types.
+ */
+type GenerationTarget = 'handler' | 'component' | 'form';
+/**
+ * Test target types.
+ */
+type TestTarget = 'handler' | 'component';
+/**
+ * Spec build type detected during build.
+ */
+type SpecBuildType = 'operation' | 'presentation' | 'form' | 'event' | 'workflow' | 'data-view' | 'telemetry' | 'migration' | 'experiment' | 'app-config' | 'integration' | 'knowledge' | 'unknown';
+/**
+ * Configuration for workspace operations.
+ */
+interface WorkspaceConfig {
+  aiProvider: 'claude' | 'openai' | 'ollama' | 'custom';
+  aiModel?: string;
+  agentMode: 'simple' | 'cursor' | 'claude-code' | 'openai-codex';
+  customEndpoint?: string | null;
+  customApiKey?: string | null;
+  outputDir: string;
+  conventions: {
+    operations: string;
+    events: string;
+    presentations: string;
+    forms: string;
+    workflows?: string;
+    'data-views'?: string;
+    dataViews?: string;
+    migrations?: string;
+    telemetry?: string;
+    experiments?: string;
+    appConfig?: string;
+    integrations?: string;
+    knowledge?: string;
+  };
+  defaultOwners: string[];
+  defaultTags: string[];
+  ruleSync?: RuleSyncConfig;
+}
+/**
+ * Default workspace configuration.
+ */
+declare const DEFAULT_WORKSPACE_CONFIG: WorkspaceConfig;
+/**
+ * AI prompt context for spec generation.
+ */
+interface SpecGenerationContext {
+  description: string;
+  kind?: OpKind;
+  presentationKind?: PresentationKind;
+}
+/**
+ * AI prompt context for code generation.
+ */
+interface CodeGenerationContext {
+  specCode: string;
+  targetPath?: string;
+  existingCode?: string;
+}
+//#endregion
+export { AIGenerationOptions, CodeGenerationContext, DEFAULT_WORKSPACE_CONFIG, GenerationResult, GenerationTarget, SpecBuildType, SpecGenerationContext, TestTarget, WorkspaceConfig };
+//# sourceMappingURL=generation-types.d.ts.map

package/dist/types/generation-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation-types.d.ts","names":[],"sources":["../../src/types/generation-types.ts"],"sourcesContent":[],"mappings":";;;;;;AAqBA;AASA;AAKA;AAKY,UA7BK,mBAAA,CA6BQ;EAkBR,QAAA,EAAA,QAAe,GAAA,QAAA,GAwBnB,QAAA,GAAA,QAAc;EAMd,KAAA,CAAA,EAAA,MAAA;EAiBI,QAAA,CAAA,EAAA,MAAA;EASA,MAAA,CAAA,EAAA,OAAA;;;;;UA7FA,gBAAA;;;YAGL;;;;;KAMA,gBAAA;;;;KAKA,UAAA;;;;KAKA,aAAA;;;;UAkBK,eAAA;;;;;;;;;;;;;;;;;;;;;;;;aAwBJ;;;;;cAMA,0BAA0B;;;;UAiBtB,qBAAA;;SAER;qBACY;;;;;UAMJ,qBAAA"}

package/dist/types/generation-types.js

@@ -0,0 +1,21 @@
+//#region src/types/generation-types.ts
+/**
+* Default workspace configuration.
+*/
+const DEFAULT_WORKSPACE_CONFIG = {
+	aiProvider: "claude",
+	agentMode: "simple",
+	outputDir: "./src",
+	conventions: {
+		operations: "interactions/commands|queries",
+		events: "events",
+		presentations: "presentations",
+		forms: "forms"
+	},
+	defaultOwners: [],
+	defaultTags: []
+};
+
+//#endregion
+export { DEFAULT_WORKSPACE_CONFIG };
+//# sourceMappingURL=generation-types.js.map

package/dist/types/generation-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation-types.js","names":[],"sources":["../../src/types/generation-types.ts"],"sourcesContent":["/**\n * Code generation related type definitions.\n */\n\nimport type { OpKind } from '@contractspec/lib.contracts';\nimport type { SpecType, PresentationKind } from './spec-types';\nimport type { RuleSyncConfig } from './rulesync-types';\n\n/**\n * AI provider options for generation.\n */\nexport interface AIGenerationOptions {\n  provider: 'claude' | 'openai' | 'ollama' | 'custom';\n  model?: string;\n  endpoint?: string;\n  stream?: boolean;\n}\n\n/**\n * Result of code generation.\n */\nexport interface GenerationResult {\n  code: string;\n  filePath: string;\n  specType: SpecType;\n}\n\n/**\n * Build target types.\n */\nexport type GenerationTarget = 'handler' | 'component' | 'form';\n\n/**\n * Test target types.\n */\nexport type TestTarget = 'handler' | 'component';\n\n/**\n * Spec build type detected during build.\n */\nexport type SpecBuildType =\n  | 'operation'\n  | 'presentation'\n  | 'form'\n  | 'event'\n  | 'workflow'\n  | 'data-view'\n  | 'telemetry'\n  | 'migration'\n  | 'experiment'\n  | 'app-config'\n  | 'integration'\n  | 'knowledge'\n  | 'unknown';\n\n/**\n * Configuration for workspace operations.\n */\nexport interface WorkspaceConfig {\n  aiProvider: 'claude' | 'openai' | 'ollama' | 'custom';\n  aiModel?: string;\n  agentMode: 'simple' | 'cursor' | 'claude-code' | 'openai-codex';\n  customEndpoint?: string | null;\n  customApiKey?: string | null;\n  outputDir: string;\n  conventions: {\n    operations: string;\n    events: string;\n    presentations: string;\n    forms: string;\n    workflows?: string;\n    'data-views'?: string;\n    dataViews?: string;\n    migrations?: string;\n    telemetry?: string;\n    experiments?: string;\n    appConfig?: string;\n    integrations?: string;\n    knowledge?: string;\n  };\n  defaultOwners: string[];\n  defaultTags: string[];\n  ruleSync?: RuleSyncConfig;\n}\n\n/**\n * Default workspace configuration.\n */\nexport const DEFAULT_WORKSPACE_CONFIG: WorkspaceConfig = {\n  aiProvider: 'claude',\n  agentMode: 'simple',\n  outputDir: './src',\n  conventions: {\n    operations: 'interactions/commands|queries',\n    events: 'events',\n    presentations: 'presentations',\n    forms: 'forms',\n  },\n  defaultOwners: [],\n  defaultTags: [],\n};\n\n/**\n * AI prompt context for spec generation.\n */\nexport interface SpecGenerationContext {\n  description: string;\n  kind?: OpKind;\n  presentationKind?: PresentationKind;\n}\n\n/**\n * AI prompt context for code generation.\n */\nexport interface CodeGenerationContext {\n  specCode: string;\n  targetPath?: string;\n  existingCode?: string;\n}\n"],"mappings":";;;;AAwFA,MAAa,2BAA4C;CACvD,YAAY;CACZ,WAAW;CACX,WAAW;CACX,aAAa;EACX,YAAY;EACZ,QAAQ;EACR,eAAe;EACf,OAAO;EACR;CACD,eAAe,EAAE;CACjB,aAAa,EAAE;CAChB"}

package/dist/types/llm-types.d.ts

@@ -0,0 +1,138 @@
+import { Stability } from "./spec-types.js";
+
+//#region src/types/llm-types.d.ts
+
+/**
+ * LLM export format options.
+ * - **full**: Complete information including source code and all details (for deep LLM context)
+ * - **prompt**: Concise with implementation instructions (actionable for LLM)
+ * - **context**: Brief summary with counts and key fields (lightweight overview)
+ */
+type LLMExportFormat = 'full' | 'prompt' | 'context';
+/**
+ * Agent types for implementation guides.
+ */
+type AgentType = 'claude-code' | 'cursor-cli' | 'generic-mcp';
+/**
+ * Verification tier for implementation checks.
+ */
+type VerificationTier = 'quick' | 'standard' | 'thorough';
+/**
+ * Reference to a related spec (operation, event, policy, test, etc.)
+ */
+interface SpecRef {
+  name: string;
+  version: string;
+}
+/**
+ * Metadata extracted from a parsed spec.
+ */
+interface ParsedSpecMeta {
+  /** Unique identifier for the spec */
+  key: string;
+  /** Version number */
+  version: string;
+  /** Human-readable description */
+  description?: string;
+  /** Stability level */
+  stability?: Stability;
+  /** Team or individual owners */
+  owners?: string[];
+  /** Categorization tags */
+  tags?: string[];
+  /** Business goal this spec achieves */
+  goal?: string;
+  /** Additional context for implementation */
+  context?: string;
+}
+/**
+ * Lightweight representation of a spec extracted from source code.
+ * This is used for LLM export without requiring full compilation.
+ */
+interface ParsedSpec {
+  /** Spec metadata */
+  meta: ParsedSpecMeta;
+  /** Type of spec (operation, event, feature, etc.) */
+  specType: string;
+  /** For operations: command or query */
+  kind?: 'command' | 'query' | 'event' | 'presentation' | 'capability' | 'policy' | 'type' | 'example' | 'app-config' | 'integration' | 'workflow' | 'unknown';
+  /** Whether the spec defines input/output schemas */
+  hasIo?: boolean;
+  /** Whether the spec defines policy rules */
+  hasPolicy?: boolean;
+  /** Whether the spec defines a payload */
+  hasPayload?: boolean;
+  /** Whether the spec defines content */
+  hasContent?: boolean;
+  /** Whether the spec has a definition block */
+  hasDefinition?: boolean;
+  /** Events this spec may emit */
+  emittedEvents?: SpecRef[];
+  /** Policy specs referenced by this spec */
+  policyRefs?: SpecRef[];
+  /** Test specs associated with this spec */
+  testRefs?: SpecRef[];
+  /** Path to the source file */
+  filePath?: string;
+  /** The actual source code block of the spec */
+  sourceBlock?: string;
+  /** Operations included in this feature */
+  operations?: SpecRef[];
+  /** Events included in this feature */
+  events?: SpecRef[];
+  /** Presentations included in this feature */
+  presentations?: SpecRef[];
+}
+/**
+ * Options for spec-to-markdown conversion.
+ */
+interface SpecToMarkdownOptions {
+  /** Export format */
+  format: LLMExportFormat;
+  /** Indentation depth for nested specs */
+  depth?: number;
+  /** Include source code blocks */
+  includeSource?: boolean;
+  /** Include implementation instructions */
+  includeInstructions?: boolean;
+}
+/**
+ * Result of LLM export operation.
+ */
+interface LLMExportResult {
+  /** Generated markdown content */
+  content: string;
+  /** Number of specs included */
+  specCount: number;
+  /** Format used for export */
+  format: LLMExportFormat;
+}
+/**
+ * Result of implementation verification.
+ */
+interface VerificationResult {
+  /** Whether verification passed */
+  passed: boolean;
+  /** Issues found during verification */
+  issues: VerificationIssue[];
+  /** Suggestions for improvement */
+  suggestions: string[];
+  /** Verification tier used */
+  tier: VerificationTier;
+}
+/**
+ * Single verification issue.
+ */
+interface VerificationIssue {
+  /** Severity of the issue */
+  severity: 'error' | 'warning' | 'info';
+  /** Issue message */
+  message: string;
+  /** Location in the spec or implementation */
+  location?: string;
+  /** Suggested fix */
+  suggestion?: string;
+}
+//#endregion
+export { AgentType, LLMExportFormat, LLMExportResult, ParsedSpec, ParsedSpecMeta, SpecRef, SpecToMarkdownOptions, VerificationIssue, VerificationResult, VerificationTier };
+//# sourceMappingURL=llm-types.d.ts.map

package/dist/types/llm-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-types.d.ts","names":[],"sources":["../../src/types/llm-types.ts"],"sourcesContent":[],"mappings":";;;;AA6BA;AAQA;AAuBA;;;;AAkCa,KAhFD,eAAA,GAgFC,MAAA,GAAA,QAAA,GAAA,SAAA;;;;AAYY,KAvFb,SAAA,GAuFa,aAAA,GAAA,YAAA,GAAA,aAAA;AAMzB;AAcA;AAYA;AAciB,KAhIL,gBAAA,GAgIsB,OAAA,GAAA,UAAA,GAAA,UAAA;;;;UA3HjB,OAAA;;;;;;;UAQA,cAAA;;;;;;;;cAQH;;;;;;;;;;;;;;UAeG,UAAA;;QAET;;;;;;;;;;;;;;;;kBA4BU;;eAEH;;aAEF;;;;;;eAQE;;WAEJ;;kBAEO;;;;;UAMD,qBAAA;;UAEP;;;;;;;;;;;UAYO,eAAA;;;;;;UAMP;;;;;UAMO,kBAAA;;;;UAIP;;;;QAIF;;;;;UAMS,iBAAA"}

package/dist/types/rulesync-types.d.ts

@@ -0,0 +1,24 @@
+import { RuleSyncTarget } from "@contractspec/lib.contracts";
+
+//#region src/types/rulesync-types.d.ts
+
+/**
+ * Configuration for AI agent rules synchronization.
+ */
+interface RuleSyncConfig {
+  /** Enable automated rule synchronization */
+  enabled: boolean;
+  /** Root directory for source rule files */
+  rulesDir: string;
+  /** Source rule files (glob patterns) */
+  rules: string[];
+  /** Synchronization targets (tools to generate rules for) */
+  targets: RuleSyncTarget[];
+  /** Automatically synchronize rules on workspace changes or builds */
+  autoSync: boolean;
+  /** Whether to eject/copy source rules instead of generating from Unified Rules */
+  ejectMode: boolean;
+}
+//#endregion
+export { RuleSyncConfig };
+//# sourceMappingURL=rulesync-types.d.ts.map

package/dist/types/rulesync-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulesync-types.d.ts","names":[],"sources":["../../src/types/rulesync-types.ts"],"sourcesContent":[],"mappings":";;;;;;;UASiB,cAAA;;;;;;;;WAQN"}

package/dist/types/spec-types.d.ts

@@ -0,0 +1,343 @@
+import { OpKind } from "@contractspec/lib.contracts";
+
+//#region src/types/spec-types.d.ts
+
+type SpecType = 'operation' | 'event' | 'presentation' | 'form' | 'feature' | 'workflow' | 'data-view' | 'migration' | 'telemetry' | 'experiment' | 'app-config' | 'integration' | 'knowledge';
+type PresentationKind = 'web_component' | 'markdown' | 'data';
+type Stability = 'experimental' | 'beta' | 'stable' | 'deprecated';
+type StepType = 'human' | 'automation' | 'decision';
+interface BaseSpecData {
+  name: string;
+  version: string;
+  description: string;
+  owners: string[];
+  tags: string[];
+  stability: Stability;
+}
+interface OperationSpecData extends BaseSpecData {
+  kind: OpKind;
+  goal: string;
+  context: string;
+  hasInput: boolean;
+  hasOutput: boolean;
+  auth: 'anonymous' | 'user' | 'admin';
+  flags: string[];
+  emitsEvents: boolean;
+}
+interface EventSpecData extends BaseSpecData {
+  piiFields: string[];
+}
+interface PresentationSpecData extends BaseSpecData {
+  presentationKind: PresentationKind;
+}
+type FormSpecData = BaseSpecData;
+interface FeatureSpecData extends BaseSpecData {
+  key: string;
+  operations: {
+    name: string;
+    version: string;
+  }[];
+  events: {
+    name: string;
+    version: string;
+  }[];
+  presentations: {
+    name: string;
+    version: string;
+  }[];
+}
+interface WorkflowStepData {
+  id: string;
+  label: string;
+  type: StepType;
+  description?: string;
+  operation?: {
+    name: string;
+    version: string;
+  };
+  form?: {
+    key: string;
+    version: string;
+  };
+}
+interface WorkflowTransitionData {
+  from: string;
+  to: string;
+  condition?: string;
+}
+interface WorkflowSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  entryStepId?: string;
+  steps: WorkflowStepData[];
+  transitions: WorkflowTransitionData[];
+  policyFlags: string[];
+}
+type DataViewKind = 'list' | 'detail' | 'table' | 'grid';
+interface DataViewFieldData {
+  key: string;
+  label: string;
+  dataPath: string;
+  format?: string;
+  sortable?: boolean;
+  filterable?: boolean;
+}
+interface DataViewSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  entity: string;
+  kind: DataViewKind;
+  primaryOperation: {
+    name: string;
+    version: string;
+  };
+  itemOperation?: {
+    name: string;
+    version: string;
+  };
+  fields: DataViewFieldData[];
+  primaryField?: string;
+  secondaryFields?: string[];
+}
+type TelemetryPrivacy = 'public' | 'internal' | 'pii' | 'sensitive';
+interface TelemetryPropertyData {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'timestamp' | 'json';
+  required?: boolean;
+  pii?: boolean;
+  redact?: boolean;
+  description?: string;
+}
+interface TelemetryAnomalyRuleData {
+  metric: string;
+  min?: number;
+  max?: number;
+}
+interface TelemetryEventData {
+  name: string;
+  version: string;
+  what: string;
+  who?: string;
+  why?: string;
+  privacy: TelemetryPrivacy;
+  properties: TelemetryPropertyData[];
+  retentionDays?: number;
+  retentionPolicy?: 'archive' | 'delete';
+  samplingRate?: number;
+  samplingConditions?: string;
+  anomalyEnabled?: boolean;
+  anomalyMinimumSample?: number;
+  anomalyRules?: TelemetryAnomalyRuleData[];
+  anomalyActions?: ('alert' | 'log' | 'trigger_regen')[];
+  tags?: string[];
+}
+interface TelemetryProviderData {
+  type: 'posthog' | 'segment' | 'opentelemetry' | 'internal';
+  config: string;
+}
+interface TelemetrySpecData extends BaseSpecData {
+  domain: string;
+  defaultRetentionDays?: number;
+  defaultSamplingRate?: number;
+  providers?: TelemetryProviderData[];
+  anomalyEnabled?: boolean;
+  anomalyCheckIntervalMs?: number;
+  events: TelemetryEventData[];
+}
+interface ExperimentVariantOverrideData {
+  type: 'dataView' | 'workflow' | 'theme' | 'policy' | 'presentation';
+  target: string;
+  version?: string;
+}
+interface ExperimentVariantData {
+  id: string;
+  name: string;
+  description?: string;
+  weight?: number;
+  overrides?: ExperimentVariantOverrideData[];
+}
+interface TargetingRuleData {
+  variantId: string;
+  percentage?: number;
+  policy?: {
+    name: string;
+    version?: string;
+  };
+  expression?: string;
+}
+interface RandomAllocationData {
+  type: 'random';
+  salt?: string;
+}
+interface StickyAllocationData {
+  type: 'sticky';
+  attribute: 'userId' | 'organizationId' | 'sessionId';
+  salt?: string;
+}
+interface TargetedAllocationData {
+  type: 'targeted';
+  fallback?: 'control' | 'random';
+  rules: TargetingRuleData[];
+}
+type ExperimentAllocationData = RandomAllocationData | StickyAllocationData | TargetedAllocationData;
+interface ExperimentMetricData {
+  name: string;
+  eventName: string;
+  eventVersion: string;
+  aggregation: 'count' | 'avg' | 'p75' | 'p90' | 'p95' | 'p99';
+  target?: string;
+}
+interface ExperimentSpecData extends BaseSpecData {
+  domain: string;
+  controlVariant: string;
+  variants: ExperimentVariantData[];
+  allocation: ExperimentAllocationData;
+  successMetrics?: ExperimentMetricData[];
+}
+interface AppConfigMappingData {
+  slot: string;
+  name: string;
+  version?: string;
+}
+interface AppConfigFeatureFlagData {
+  key: string;
+  enabled: boolean;
+  variant?: string;
+  description?: string;
+}
+interface AppRouteConfigData {
+  path: string;
+  label?: string;
+  dataView?: string;
+  workflow?: string;
+  guardName?: string;
+  guardVersion?: string | number;
+  featureFlag?: string;
+  experimentName?: string;
+  experimentVersion?: string | number;
+}
+interface AppBlueprintSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  appId: string;
+  capabilitiesEnabled: string[];
+  capabilitiesDisabled: string[];
+  featureIncludes: string[];
+  featureExcludes: string[];
+  dataViews: AppConfigMappingData[];
+  workflows: AppConfigMappingData[];
+  policyRefs: {
+    name: string;
+    version?: string;
+  }[];
+  theme?: {
+    name: string;
+    version: string;
+  };
+  themeFallbacks: {
+    name: string;
+    version: string;
+  }[];
+  telemetry?: {
+    name: string;
+    version?: string;
+  };
+  activeExperiments: {
+    name: string;
+    version?: string;
+  }[];
+  pausedExperiments: {
+    name: string;
+    version?: string;
+  }[];
+  featureFlags: AppConfigFeatureFlagData[];
+  routes: AppRouteConfigData[];
+  notes?: string;
+}
+type MigrationStepKind = 'schema' | 'data' | 'validation';
+interface MigrationStepData {
+  kind: MigrationStepKind;
+  description?: string;
+  sql?: string;
+  script?: string;
+  assertion?: string;
+  timeoutMs?: number;
+  retries?: number;
+  preChecks?: {
+    description: string;
+    expression: string;
+  }[];
+  postChecks?: {
+    description: string;
+    expression: string;
+  }[];
+}
+interface MigrationSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  dependencies: string[];
+  up: MigrationStepData[];
+  down?: MigrationStepData[];
+}
+type IntegrationCategoryData = 'payments' | 'email' | 'calendar' | 'sms' | 'ai-llm' | 'ai-voice' | 'speech-to-text' | 'vector-db' | 'storage' | 'accounting' | 'crm' | 'helpdesk' | 'open-banking' | 'custom';
+type IntegrationConfigFieldType = 'string' | 'number' | 'boolean';
+type IntegrationOwnershipModeData = 'managed' | 'byok';
+type IntegrationHealthCheckMethod = 'ping' | 'list' | 'custom';
+interface IntegrationCapabilityRefData {
+  key: string;
+  version: string;
+}
+interface IntegrationCapabilityRequirementData {
+  key: string;
+  version?: string;
+  optional?: boolean;
+  reason?: string;
+}
+interface IntegrationConfigFieldData {
+  key: string;
+  type: IntegrationConfigFieldType;
+  required: boolean;
+  description?: string;
+}
+type IntegrationSecretFieldData = IntegrationConfigFieldData;
+interface IntegrationSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  displayName: string;
+  category: IntegrationCategoryData;
+  supportedModes: IntegrationOwnershipModeData[];
+  capabilitiesProvided: IntegrationCapabilityRefData[];
+  capabilitiesRequired: IntegrationCapabilityRequirementData[];
+  configFields: IntegrationConfigFieldData[];
+  secretFields: IntegrationSecretFieldData[];
+  docsUrl?: string;
+  rateLimitRpm?: number;
+  rateLimitRph?: number;
+  healthCheckMethod: IntegrationHealthCheckMethod;
+  healthCheckTimeoutMs?: number;
+  byokSetupInstructions?: string;
+  byokRequiredScopes?: string[];
+}
+type KnowledgeCategoryData = 'canonical' | 'operational' | 'external' | 'ephemeral';
+type KnowledgeTrustLevel = 'high' | 'medium' | 'low';
+interface KnowledgeRetentionData {
+  ttlDays?: number | null;
+  archiveAfterDays?: number;
+}
+interface KnowledgeSpaceSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  displayName: string;
+  category: KnowledgeCategoryData;
+  retention: KnowledgeRetentionData;
+  policyName?: string;
+  policyVersion?: string | number;
+  trustLevel: KnowledgeTrustLevel;
+  automationWritable: boolean;
+  embeddingModel?: string;
+  chunkSize?: number;
+  vectorDbIntegration?: string;
+}
+//#endregion
+export { AppBlueprintSpecData, AppConfigFeatureFlagData, AppConfigMappingData, AppRouteConfigData, BaseSpecData, DataViewFieldData, DataViewKind, DataViewSpecData, EventSpecData, ExperimentAllocationData, ExperimentMetricData, ExperimentSpecData, ExperimentVariantData, ExperimentVariantOverrideData, FeatureSpecData, FormSpecData, IntegrationCapabilityRefData, IntegrationCapabilityRequirementData, IntegrationCategoryData, IntegrationConfigFieldData, IntegrationConfigFieldType, IntegrationHealthCheckMethod, IntegrationOwnershipModeData, IntegrationSecretFieldData, IntegrationSpecData, KnowledgeCategoryData, KnowledgeRetentionData, KnowledgeSpaceSpecData, KnowledgeTrustLevel, MigrationSpecData, MigrationStepData, MigrationStepKind, OperationSpecData, PresentationKind, PresentationSpecData, RandomAllocationData, SpecType, Stability, StepType, StickyAllocationData, TargetedAllocationData, TargetingRuleData, TelemetryAnomalyRuleData, TelemetryEventData, TelemetryPrivacy, TelemetryPropertyData, TelemetryProviderData, TelemetrySpecData, WorkflowSpecData, WorkflowStepData, WorkflowTransitionData };
+//# sourceMappingURL=spec-types.d.ts.map

package/dist/types/spec-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-types.d.ts","names":[],"sources":["../../src/types/spec-types.ts"],"sourcesContent":[],"mappings":"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"}