@taylorwong/ichartjs 2.0.1

package/src/validation.mjs

@@ -0,0 +1,106 @@
+/**
+ * Business data validation against declared schemas and cross-field rules.
+ * Returns normalized rows plus structured errors and warnings.
+ */
+import { copyJSON, isRecord, issue, validateDataSchema } from './schema.mjs';
+
+export function isDateOnly(value) {
+  if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+  const time = Date.parse(`${value}T00:00:00.000Z`);
+  return Number.isFinite(time) && new Date(time).toISOString().slice(0, 10) === value;
+}
+
+export function cyclicIds(rows, key, field) {
+  const degree = new Map(rows.map(row => [row[key], 0])), next = new Map(rows.map(row => [row[key], []]));
+  rows.forEach(row => (row[field] || []).forEach(value => { const id = typeof value === 'string' ? value : value?.id; if (degree.has(id)) { degree.set(row[key], degree.get(row[key]) + 1); next.get(id).push(row[key]); } }));
+  const queue = [...degree.keys()].filter(id => degree.get(id) === 0);
+  for (let index = 0; index < queue.length; index += 1) next.get(queue[index]).forEach(id => { degree.set(id, degree.get(id) - 1); if (degree.get(id) === 0) queue.push(id); });
+  return [...degree.keys()].filter(id => degree.get(id) > 0);
+}
+
+export function validateData(input, schema, options = {}) {
+  const contract = validateDataSchema(schema), errors = [...contract.errors], warnings = [], normalizations = [];
+  let original = [], rows = [], references = {};
+  if (!contract.valid) return { valid: false, errors, warnings, normalizations, original, rows };
+  try {
+    original = copyJSON(input);
+    references = copyJSON(options.references ?? {});
+    if (!Array.isArray(original) || !isRecord(references)) throw new Error('Data must be a row array; references must be a table object.');
+    rows = copyJSON(original);
+  } catch (error) { return { valid: false, errors: [issue('INVALID_DATA', 'values', error.message)], warnings, normalizations, original: [], rows: [] }; }
+  if (options.progressUnit !== undefined && !['ratio', 'percent'].includes(options.progressUnit)) errors.push(issue('PROGRESS_UNIT', 'options.progressUnit', 'Use ratio or percent explicitly.'));
+  const normalizeField = (object, name, field, path) => {
+    if (!Object.hasOwn(object, name)) {
+      if (Object.hasOwn(field, 'default')) {
+        object[name] = copyJSON(field.default);
+        normalizations.push({ path, beforePresent: false, after: copyJSON(object[name]), reason: 'default' });
+      } else { if (field.required) errors.push(issue('REQUIRED', path, 'Required field is missing.')); return; }
+    }
+    const value = object[name];
+    if (value === null && field.nullable) return;
+    if (field.anyOf) {
+      const option = field.anyOf.find(candidate => candidate.type === 'string' ? typeof value === 'string' : candidate.type === 'object' ? isRecord(value) : candidate.type === 'array' ? Array.isArray(value) : candidate.type === 'number' ? typeof value === 'number' && Number.isFinite(value) : candidate.type === 'boolean' ? typeof value === 'boolean' : candidate.type === 'date' ? isDateOnly(value) : candidate.type === 'enum' ? candidate.values.includes(value) : false);
+      if (!option) errors.push(issue('FIELD_VALUE', path, 'Value does not match any supported field shape.'));
+      else normalizeField(object, name, { ...option, required: field.required }, path);
+      return;
+    }
+    const correctType = field.type === 'string' ? typeof value === 'string' && (!field.required || value.length > 0)
+      : field.type === 'number' ? typeof value === 'number' && Number.isFinite(value)
+        : field.type === 'boolean' ? typeof value === 'boolean'
+          : field.type === 'date' ? isDateOnly(value)
+            : field.type === 'enum' ? field.values.includes(value)
+              : field.type === 'array' ? Array.isArray(value) : isRecord(value);
+    if (!correctType) { errors.push(issue('FIELD_VALUE', path, `Expected ${field.type}.`, field.type === 'date' ? 'Use a real calendar date YYYY-MM-DD; timestamps are not date-only values.' : 'Use the declared type; automatic string/number coercion is disabled.')); return; }
+    if (field.type === 'number' && ((field.min !== undefined && value < field.min) || (field.max !== undefined && value > field.max))) errors.push(issue('OUT_OF_RANGE', path, 'Value is outside the declared limits.'));
+    if (field.type === 'array') {
+      if (field.unique && new Set(value.map(item => JSON.stringify(item))).size !== value.length) errors.push(issue('DUPLICATE_VALUE', path, 'Array values must be unique.'));
+      value.forEach((item, index) => normalizeField(value, index, field.items, `${path}.${index}`));
+    }
+    if (field.type === 'object') {
+      Object.keys(value).filter(key => !Object.hasOwn(field.properties, key)).forEach(key => errors.push(issue('UNKNOWN_FIELD', `${path}.${key}`, 'Object property is not declared.')));
+      Object.entries(field.properties).forEach(([key, child]) => normalizeField(value, key, child, `${path}.${key}`));
+    }
+  };
+  const ids = new Set();
+  rows.forEach((row, index) => {
+    const path = `values.${index}`;
+    if (!isRecord(row)) { errors.push(issue('INVALID_RECORD', path, 'Each row must be an object.')); return; }
+    if (options.progressUnit === 'ratio' && schema.name === 'project-task' && Object.hasOwn(row, 'progress')) {
+      if (typeof row.progress !== 'number' || row.progress < 0 || row.progress > 1) errors.push(issue('PROGRESS_UNIT', `${path}.progress`, 'Ratio progress must be between 0 and 1.'));
+      else { const before = row.progress; row.progress *= 100; normalizations.push({ path: `${path}.progress`, beforePresent: true, before, after: row.progress, reason: 'ratio-to-percent' }); }
+    }
+    Object.keys(row).filter(key => !Object.hasOwn(schema.fields, key)).forEach(key => errors.push(issue('UNKNOWN_FIELD', `${path}.${key}`, 'Field is not declared in the business schema.')));
+    Object.entries(schema.fields).forEach(([name, field]) => normalizeField(row, name, field, `${path}.${name}`));
+    if (ids.has(row[schema.key])) errors.push(issue('DUPLICATE_ID', `${path}.${schema.key}`, 'Primary keys must be unique.'));
+    ids.add(row[schema.key]);
+  });
+  if (!errors.length) {
+    rows.forEach((row, index) => {
+      for (const [name, field] of Object.entries(schema.fields)) {
+        if (!field.references || row[name] == null) continue;
+        let targets = ids;
+        if (field.references !== 'self') {
+          const table = references[field.references];
+          if (!Array.isArray(table) || table.some(id => typeof id !== 'string')) { errors.push(issue('REFERENCE_CONTEXT', `references.${field.references}`, 'Supply the trusted related record IDs before validating references.')); continue; }
+          targets = new Set(table);
+        }
+        const values = (Array.isArray(row[name]) ? row[name] : [row[name]]).map(value => typeof value === 'string' ? value : value?.id);
+        values.forEach(id => { if (!targets.has(id)) errors.push(issue('MISSING_REFERENCE', `values.${index}.${name}`, `Unknown referenced ID: ${id}`)); });
+      }
+      for (const rule of schema.rules || []) {
+        let valid = true;
+        if (rule.kind === 'compare' && row[rule.left] != null && row[rule.right] != null) {
+          const left = row[rule.left], right = row[rule.right];
+          valid = { gte: left >= right, gt: left > right, lte: left <= right, lt: left < right, eq: left === right }[rule.op];
+        } else if (rule.kind === 'implies') valid = JSON.stringify(row[rule.if.field]) !== JSON.stringify(rule.if.equals) || JSON.stringify(row[rule.then.field]) === JSON.stringify(rule.then.equals);
+        if (!valid) errors.push(issue('BUSINESS_RULE', `values.${index}`, rule.message || `Rule ${rule.id} failed.`, 'Update related fields together.', rule.id));
+      }
+    });
+    for (const [name, field] of Object.entries(schema.fields)) if (field.acyclic) {
+      const blocked = cyclicIds(rows, schema.key, name);
+      if (blocked.length) errors.push(issue('CYCLIC_DEPENDENCY', `values.*.${name}`, `Cycle blocks records: ${blocked.join(', ')}`));
+    }
+  }
+  if (normalizations.length) warnings.push(issue('NORMALIZED_DATA', 'values', 'Explicit conversions/defaults were applied to the returned copy; input is unchanged.', 'Use the normalized rows as the preview baseline.'));
+  return { valid: errors.length === 0, errors, warnings, normalizations, original, rows };
+}

package/types/index.d.ts

@@ -0,0 +1,134 @@
+export type Renderer = 'canvas' | 'svg' | 'auto';
+export type ChartType = 'line' | 'area' | 'bar' | 'column' | 'pie' | 'scatter' | 'funnel' | 'gauge' | 'heatmap' | 'radar' | 'gantt' | 'timeline' | 'milestone' | 'burndown' | 'flow' | 'swimlane';
+export type ThemeMode = 'auto' | 'light' | 'dark' | 'contrast';
+export type ThemePreset = 'auto' | 'analysis' | 'dashboard' | 'report' | 'presentation' | 'project' | 'diagram';
+export type ThemePalette = 'auto' | 'categorical' | 'sequential' | 'diverging' | 'status';
+export type ExportKind = 'json' | 'svg' | 'png' | 'jpeg' | 'jpg' | 'image/png' | 'image/jpeg' | 'image/svg+xml' | 'application/json';
+export type ExportAs = 'string' | 'dataurl' | 'blob' | 'object';
+export interface ExportError { valid: false; code: string; rasterCode?: string; message?: string; suggestion?: string; [key: string]: unknown }
+export interface ThemeConfig { mode?: ThemeMode; preset?: ThemePreset; palette?: ThemePalette; tokens?: Record<string, unknown>; branding?: boolean | { enabled?: boolean; [key: string]: unknown }; [key: string]: unknown; }
+export interface StyleRecommendation { version: '1.0'; preset: Exclude<ThemePreset, 'auto'>; mode: ThemeMode; resolvedMode: Exclude<ThemeMode, 'auto'>; palette: Exclude<ThemePalette, 'auto'>; reasons: string[]; warnings: Diagnostic[]; userOverride: boolean; }
+export interface ResolvedTheme extends ThemeConfig { name: string; resolvedMode: Exclude<ThemeMode, 'auto'>; background: string; surface: string; text: string; muted: string; axis: string; grid: string; border: string; focus: string; selection: string; colors: string[]; palettes: Record<string, unknown>; status: Record<string, string>; typography: Record<string, { size: number; weight: number; lineHeight: number; font: string }>; layout: Record<string, unknown>; marks: Record<string, unknown>; reasons: string[]; warnings: Diagnostic[]; }
+export interface Diagnostic { code: string; path?: string; message: string; expected?: unknown; suggestion?: string; [key: string]: unknown; }
+export interface DataFieldInfo { name: string; type: 'quantitative' | 'temporal' | 'category' | 'unknown'; role: 'identifier' | 'measure' | 'temporal-dimension' | 'dimension'; unit: string | null; cardinality: number; validCount: number; nullCount: number; min?: number; max?: number; temporalMin?: string; temporalMax?: string; }
+export interface DataInspection { version: '1.0'; rows: number; fields: DataFieldInfo[]; dimensions: string[]; measures: string[]; temporalFields: string[]; missingValueCount: number; warnings: Diagnostic[]; }
+export interface ChartCapability { type: ChartType; family: string; intents: string[]; required: string[]; optional: string[]; dataShapes: string[]; interactions: string[]; features: Record<string, 'supported' | 'not-applicable' | 'degraded'>; renderers: Array<'canvas' | 'svg'>; exports: string[]; limits: Record<string, number>; }
+export interface RuntimeCapabilities { version: '2.0'; contractVersion: '1.0'; chartTypes: ChartType[]; charts: Record<ChartType, ChartCapability>; intents: string[]; renderers: Array<'canvas' | 'svg'>; interactions: string[]; exports: Array<'png' | 'svg' | 'json' | 'jpeg'>; styleSystem: { modes: ThemeMode[]; presets: ThemePreset[]; palettes: ThemePalette[]; switchable: boolean; automatic: boolean; [key: string]: unknown }; headless: { preview?: boolean; json: boolean; svg: boolean; png: boolean | string }; export: { types: string[]; mime: Record<string, string>; browser: Record<string, boolean>; headless: Record<string, string | boolean>; methods: string[]; options: Record<string, unknown>; branding: Record<string, unknown> }; branding: { defaultEnabled: boolean; signature: string; options: Record<string, unknown> }; [key: string]: unknown; }
+export interface ChartPlan { version: '1.0'; intent: string; primary: ChartType; alternatives: ChartType[]; confidence: number; reasons: string[]; requiredFields: string[]; suggestedEncodings: { dimension: string | null; measure: string | null; secondaryMeasure: string | null }; assumptions: string[]; warnings: Diagnostic[]; unsupportedRequests: string[]; nextActions: string[]; capability: ChartCapability; styleRecommendation: StyleRecommendation; data: DataInspection; }
+export interface ChartExplanation { version: '1.0'; type: ChartType; family: string; purpose: string; renderer: Renderer; dataCount: number; encodings: Record<string, string | string[]>; transforms: string[]; interactions: string[]; assumptions: string[]; warnings: Diagnostic[]; style: Partial<StyleRecommendation> & { name?: string }; lineage: { recordIds: string[]; sourcePreserved: boolean }; accessibility: { enabled: boolean; summary: string }; }
+export interface ChartSpec { type: ChartType; renderer?: Renderer; container?: string | Element; width?: number; height?: number; data?: Array<Record<string, unknown>> | { values?: Array<Record<string, unknown>>; [key: string]: unknown }; encoding?: Record<string, unknown>; title?: { text?: string; subtitle?: string }; legend?: { visible?: boolean; position?: string }; grid?: { visible?: boolean; color?: string }; labels?: { enabled?: boolean; format?: string | Record<string, unknown>; color?: string; font?: string }; interaction?: Record<string, boolean>; accessibility?: { enabled?: boolean; description?: string }; theme?: ThemeMode | ThemePreset | ThemeConfig | ResolvedTheme; [key: string]: unknown; }
+export interface BinTransform { type: 'bin'; field: string; output?: string; thresholds?: number; step?: number; extent?: [number, number]; }
+export interface RadarIndicator { name: string; field: string; min?: number; max?: number; }
+export type BusinessFieldType = 'string' | 'number' | 'boolean' | 'date' | 'enum' | 'array' | 'object';
+export interface BusinessField { type?: BusinessFieldType; anyOf?: BusinessField[]; required?: boolean; editable?: boolean; agentEditable?: boolean; nullable?: boolean; default?: unknown; min?: number; max?: number; values?: string[]; items?: BusinessField; properties?: Record<string, BusinessField>; references?: string; acyclic?: boolean; unique?: boolean; }
+export interface BusinessDataSchema { name: string; version: '1.0'; key: string; fields: Record<string, BusinessField>; rules?: Array<Record<string, unknown>>; }
+
+export interface LinkedFilters { owner?: string[]; status?: string[]; priority?: string[]; sprint?: string[]; label?: string[]; }
+export interface LinkedState { filters: Required<LinkedFilters>; selection: string[]; selectedCount: number; sourceCount: number; visibleCount: number; sourceRecordIds: string[]; visibleRecordIds: string[]; }
+
+export interface ProjectCalendarConfig { timezone?: 'UTC' | string; workingWeekdays?: number[]; holidays?: string[]; nonWorkingDayPolicy?: 'next-working-day' | 'previous-working-day' | 'allow' | string; }
+export interface DependencyRule { id: string; type?: 'finish-to-start' | 'start-to-start' | 'finish-to-finish' | 'start-to-finish'; lag?: number; lead?: number; }
+export interface ScheduleTaskResult { id: string; earliestStart: string | null; earliestFinish: string | null; latestStart: string | null; latestFinish: string | null; float: number; slack: number; critical: boolean; baselineVarianceDays: number | null; startVarianceDays: number | null; endVarianceDays: number | null; dependencies: DependencyRule[]; adjustedStart: string | null; adjustedEnd: string | null; }
+export interface ScheduleAnalysisResult { calendar: Required<ProjectCalendarConfig>; tasks: ScheduleTaskResult[]; criticalIds: string[]; criticalEdges: Array<{ from: string; to: string }>; duration: number; assumptions: string[]; warnings: Array<Record<string, unknown>>; rows: Array<Record<string, unknown>>; }
+export interface BurndownAnalysisResult { samples: Array<Record<string, unknown>>; initialScope?: number; start?: number; end?: number; forecast: { date: string | null; velocity?: number; reason: string; time?: number }; assumptions: string[]; warnings: Array<Record<string, unknown>>; }
+export interface CapacityAnalysisResult { rows: Array<Record<string, unknown>>; warnings: Array<Record<string, unknown>>; assumptions: string[]; chartType?: string; values?: Array<Record<string, unknown>>; }
+export interface ProjectAnalyticsState { linked?: LinkedState; schedule?: ScheduleAnalysisResult; burndown?: BurndownAnalysisResult; assumptions?: string[]; warnings?: Array<Record<string, unknown>>; [key: string]: unknown; }
+
+export interface EditOperation { op: string; recordId?: string; taskId?: string; nodeId?: string; nodeIds?: string[]; edgeId?: string; groupId?: string | null; policy?: 'ungroup' | 'delete-members'; field?: string; value?: unknown; changes?: Record<string, unknown>; days?: number; dependencyId?: string; position?: { x: number; y: number }; size?: { width: number; height: number }; offset?: { x: number; y: number }; delta?: { x: number; y: number }; alignment?: 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom'; laneId?: string; }
+export interface EditCommand { version?: '1.0'; type: 'edit' | 'layout-edit'; reason?: string; operations: EditOperation[]; }
+export interface EditPreview { valid: boolean; id: string; command: EditCommand; changes: Array<{ path: string; before: unknown; after: unknown; operation: string }>; patches: Array<{ op: string; path: string; value: unknown }>; affectedRecords: string[]; warnings: Array<Record<string, unknown>>; requiresConfirmation: boolean; before: unknown[]; after: unknown[]; }
+
+export interface Chart {
+  getSpec(): ChartSpec;
+  describe(): Record<string, unknown>;
+  explain(): ChartExplanation;
+  update(spec: Partial<ChartSpec>): this;
+  setData(data: Array<Record<string, unknown>>): this;
+  setTheme(theme?: ChartSpec['theme']): this;
+  getTheme(): ResolvedTheme;
+  resize(width?: number, height?: number): this;
+  resetZoom(): this;
+  zoomTo(view: Record<string, number>): this;
+  panBy(delta: { x?: number; y?: number }): this;
+  clearSelection(): this;
+  toDataURL(type?: 'image/png' | 'image/jpeg' | 'image/svg+xml'): string | ExportError;
+  toBlob(type?: 'image/png' | 'image/jpeg' | 'image/svg+xml'): Blob | ExportError;
+  export(options?: { type?: ExportKind; as?: ExportAs }): string | { version: string; spec: unknown; state: unknown } | Blob | ExportError;
+  exportAsync(options?: { type?: ExportKind; as?: ExportAs }): Promise<string | { version: string; spec: unknown; state: unknown } | Blob>;
+  download(options?: { type?: ExportKind | 'json' }): { valid: boolean; filename?: string; size?: number; type?: string; code?: string; message?: string } | ExportError | string;
+  downloadPNG(): ReturnType<Chart['download']>;
+  downloadSVG(): ReturnType<Chart['download']>;
+  downloadJSON(): ReturnType<Chart['download']>;
+  destroy(): void;
+  inspectDataSchema(): ReturnType<typeof inspectDataSchema>;
+  validateData(): Record<string, unknown>;
+  validateEdit(command: EditCommand): Record<string, unknown>;
+  previewEdit(command: EditCommand): EditPreview;
+  applyEdit(command: EditCommand, options?: { preview?: EditPreview; confirmed?: boolean; approval?: unknown; previewId?: string; expectedRevision?: number; actor?: string; source?: string; reason?: string }): Record<string, unknown>;
+  getChangeSet(): Record<string, unknown> | null;
+  getState(): Record<string, unknown>;
+  getProjectAnalytics(): ProjectAnalyticsState | null;
+  getLinkedState(): LinkedState | null;
+  setLinkedFilters(filters: LinkedFilters): this;
+  setLinkedSelection(selection: string[]): this;
+  selectNodes(nodeIds: string[], options?: { additive?: boolean }): this;
+  selectGroup(groupId: string, options?: { additive?: boolean }): this;
+  getSelectedNodeIds(): string[];
+  moveSelectedBy(delta: { x: number; y: number }, options?: Record<string, unknown>): Record<string, unknown>;
+  alignSelected(alignment: EditOperation['alignment'], options?: Record<string, unknown>): Record<string, unknown>;
+  snapSelected(options?: Record<string, unknown>): Record<string, unknown>;
+  moveGroupBy(groupId: string, delta: { x: number; y: number }, options?: Record<string, unknown>): Record<string, unknown>;
+  resizeGroup(groupId: string, size: { width: number; height: number }, options?: Record<string, unknown>): Record<string, unknown>;
+  assignSelectedToGroup(groupId: string | null, options?: Record<string, unknown>): Record<string, unknown>;
+  duplicateGroup(groupId: string, options?: Record<string, unknown>): Record<string, unknown>;
+  deleteGroup(groupId: string, options?: Record<string, unknown>): Record<string, unknown>;
+  undo(): Record<string, unknown>;
+  redo(): Record<string, unknown>;
+}
+
+export function createChart(spec: ChartSpec): Chart;
+export function normalizeSpec(spec: Partial<ChartSpec>): ChartSpec;
+export function validateSpec(spec: Partial<ChartSpec>): { valid: boolean; errors: Diagnostic[]; warnings: Diagnostic[]; normalizations: Diagnostic[]; spec: ChartSpec };
+export function normalizeData(input: unknown): { rows: Array<Record<string, unknown>>; fields: DataFieldInfo[]; warnings: Diagnostic[] };
+export function inspectData(input: unknown): DataInspection;
+export function getCapabilities(): RuntimeCapabilities;
+export function getChartCapability(type: ChartType | string): ChartCapability | null;
+export function planChart(input: unknown, options?: { intent?: string; renderer?: Renderer; context?: string; theme?: ChartSpec['theme']; preferredColorScheme?: 'light' | 'dark' }): ChartPlan;
+export function recommend(input: unknown, options?: { intent?: string; renderer?: Renderer }): { primary: ChartType; alternatives: ChartType[]; reason: string; reasons: string[]; confidence: number; requiredFields: string[]; assumptions: string[]; warnings: Diagnostic[]; nextActions: string[] };
+export function explainChart(spec: ChartSpec, model?: Record<string, unknown>): ChartExplanation;
+export function planStyle(spec?: Partial<ChartSpec>, options?: { context?: string; theme?: ChartSpec['theme']; preferredColorScheme?: 'light' | 'dark' }): StyleRecommendation;
+export function resolveTheme(theme?: ChartSpec['theme'], options?: Partial<ChartSpec> & { context?: string; preferredColorScheme?: 'light' | 'dark' }): ResolvedTheme;
+export function contrastRatio(foreground: string, background: string): number | null;
+export function validateThemeContrast(theme: ResolvedTheme): Diagnostic[];
+export const themeModes: ThemeMode[];
+export const themePresets: ThemePreset[];
+export const themePalettes: ThemePalette[];
+export const styleCapabilities: RuntimeCapabilities['styleSystem'];
+export function binData(rows: Array<Record<string, unknown>>, options: Omit<BinTransform, 'type'>): { rows: Array<Record<string, unknown>>; warnings: Array<Record<string, unknown>>; assumptions: string[] };
+export function applyTransforms(rows: Array<Record<string, unknown>>, transforms: BinTransform | BinTransform[]): { rows: Array<Record<string, unknown>>; warnings: Array<Record<string, unknown>>; assumptions: string[] };
+export function getBusinessSchema(name: string): BusinessDataSchema;
+export function inspectDataSchema(schema: BusinessDataSchema): Record<string, unknown>;
+export function validateData(values: unknown[], schema: BusinessDataSchema, options?: Record<string, unknown>): Record<string, unknown>;
+export function previewEdit(command: EditCommand, options: Record<string, unknown>): EditPreview;
+export function validateEdit(command: EditCommand, options: Record<string, unknown>): Record<string, unknown>;
+export function getEditCapabilities(schema: BusinessDataSchema): Record<string, unknown>;
+export function validateRecipe(recipe: Record<string, unknown>, capabilities?: Record<string, unknown>): Record<string, unknown>;
+
+export function normalizeProjectCalendar(input?: ProjectCalendarConfig): { calendar: Required<ProjectCalendarConfig>; warnings: Array<Record<string, unknown>> };
+export function applyWorkingCalendar(value: string | Date, options?: ProjectCalendarConfig | { calendar?: ProjectCalendarConfig }): { date: string | null; adjusted: boolean; warnings: Array<Record<string, unknown>> };
+export function normalizeDependencies(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): { rows: Array<Record<string, unknown>>; warnings: Array<Record<string, unknown>> };
+export function analyzeSchedule(rows: Array<Record<string, unknown>>, options?: { calendar?: ProjectCalendarConfig }): ScheduleAnalysisResult;
+export function analyzeBurndownSeries(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): BurndownAnalysisResult;
+export function analyzeCapacity(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): CapacityAnalysisResult;
+export function buildCapacityView(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): CapacityAnalysisResult;
+export function buildCumulativeFlowSeries(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): CapacityAnalysisResult;
+export function buildVelocitySeries(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): CapacityAnalysisResult;
+export function buildReleaseForecast(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): CapacityAnalysisResult;
+export function buildRiskMatrixSeries(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): CapacityAnalysisResult;
+export function buildIssueAgingSeries(rows: Array<Record<string, unknown>>, options?: Record<string, unknown>): CapacityAnalysisResult;
+
+export function normalizeLinkedFilters(input?: LinkedFilters): Required<LinkedFilters>;
+export function normalizeLinkedSelection(input?: string[]): string[];
+export function filterProjectRows(rows: Array<Record<string, unknown>>, linked?: { filters?: LinkedFilters } | LinkedFilters): Array<Record<string, unknown>>;
+export function createLinkedProjectState(rows: Array<Record<string, unknown>>, linked?: { filters?: LinkedFilters; selection?: string[] }): LinkedState;
+export function linkedRecordId(row: Record<string, unknown>, index?: number): string;