@svgrid/enterprise 2.5.2 → 2.6.0

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+export { setLicenseKey, clearLicenseKey, getLicenseKey, isLicenseKeySet, hasValidLicense, assertEnterpriseLicensed, nudgeEnterprise, checkLicenseKey, isLicenseExpired, getLicenseExpiry, type LicenseInfo, type LicenseStatus, } from './license';
+export { parseLicenseExpiry } from './license-core';
+export { exportGrid, copyExportToClipboard, type ExportFormat, type ExportOptions, type ExportColumn, type ExportCellStyle, type ExportStyles, type ExportHeaderFooterLine, type ExportSheet, type ExportRowSource, type ExportProgress, type ExportResult, type ClipboardFormat, type ClipboardExportOptions, } from './export';
+export { default as SvExportMenu } from './SvExportMenu.svelte';
+export { buildPdfDocDefinition, type PdfExportOptions, type PdfPageSize } from './export-pdf';
+export { printGrid, type PrintOptions } from './print';
+export { importData, readImportMatrix, mapImportMatrix, mapImportMatrixAsync, autoMapColumns, inferImportColumnTypes, type ImportFormat, type ImportFieldType, type ImportOptions, type ImportResult, type ImportProgress, type ImportColumnMap, type ImportColumnTypes, type ImportGridColumn, type ImportRowError, type ImportValidator, } from './import';
+export { default as SvImportDialog } from './SvImportDialog.svelte';
+export { installEnterprise, type EnterpriseGridApi, type EnterpriseAIApi, type EnterprisePivotApi } from './install';
+export { enableSchedulerView, SvGridScheduler } from './scheduler';
+export { enableBoardView, SvGridBoard } from './board';
+export { enablePivot } from './pivot-enable';
+export type { SchedulerProConfig } from './scheduler-config';
+export { buildDependencyGraph, topoOrder, hasCycle, requiredStart, cascade, violations, type DependencyType, type SchedulerDependency, type EventTimes, type DependencyGraph, type CascadeOptions, } from './scheduler-dependencies';
+export { expandAssignments, resourceLoad, overallocations, assignedMinutes, type SchedulerAssignment, type Allocation, type Overallocation, } from './scheduler-assignments';
+export { columnSummaries, sumReducer, countReducer, busyMinutesReducer, type ColumnReducer, type SummaryItem, } from './scheduler-summary';
+export { buildAxis, timeToX, xToTime, resolveZoom, zoomPresets, type Axis, type AxisSegment, type AxisSegmentKind, type BuildAxisOptions, type ZoomLevel, type ZoomMajorUnit, } from './scheduler-axis';
+export { buildResourceRows, visibleResourceIds, type SchedulerResourceGroup, type ResourceRow, } from './scheduler-resource-tree';
+export { heatCells, heatPeak, type HeatCell } from './scheduler-heatmap';
+export { respectsBuffer, withinDurationBounds, afterLead, type BusyEvent, type GapMin, } from './scheduler-booking';
+export { availableSlots, mergeIntervals, subtractIntervals, type Interval, type Slot, type SlotOptions, } from './scheduler-slots';
+export { mergeBusy, commonFree } from './scheduler-freebusy';
+export { createStagedEditing, type StagedChange, type StagedEditingApi, type StagedEditingEvent, } from './staged-editing';
+export { createScheduler, parseCron, cronMatches, cronMatchesParsed, isScheduleDue, nextRun, CRON_PRESETS, type Schedule, type Scheduler, type SchedulerOptions, } from './scheduling';
+export { dismissUnlicensedNudge } from './watermark';
+export { showUpgradePrompt, dismissUpgradePrompt, type EnterpriseFeatureLabel, } from './upgrade-prompt';
+export { createPivotModel, pivotAggregators, filterCollapsedPivotRows, type PivotAggregator, type PivotAggregatorId, type PivotConfig, type PivotResult, type PivotRow, type PivotRowKind, type PivotValueConfig, } from './pivot';
+export { titleCase, resolveIdField, schemaToColumns, schemaToFormFields, validateField, applyComputed, validateEntity, type EntitySchema, type EntityField, type EntityFieldType, type EntityHooks, type FormFieldDescriptor, type FormLayout, type FormSection, type StudioEditorType, type StandardSchemaV1, type StandardSchemaResult, type ValidationOp, type ValidationRuleSpec, } from './schema';
+export { planQuery, coerce, createInMemoryDataSource, createKitDataSource, createKitHandlers, createSqlDataSource, planToSql, type QueryPlan, type PlanPredicate, type PlanOp, type KitDataSourceOptions, type KitHandlerOptions, type KitScope, type KitHandlers, type KitMessage, type SqlDialect, type SqlPlan, type SqlExecutor, type SqlDataSourceConfig, type WritableDataSource, } from './sveltekit';
+export { createSupabaseDataSource, createRestDataSource, offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, introspectSupabaseTable, listSupabaseTables, createSupabaseRealtime, createRelationLookup, createSupabaseAuth, aggregateRows, chartFieldsFromSchema, normalizeFilters, buildEntitySchema, pickLabelField, linkRelationLabels, type SupabaseDataSourceConfig, type SupabaseClientLike, type RestDataSourceConfig, type RestAdapter, type OffsetLimitOptions, type IntrospectSupabaseOptions, type IntrospectedColumn, type ColumnReference, type NormalizedFilter, type NormalizedPredicate, type SupabaseRealtimeConfig, type SupabaseRealtimeClientLike, type SupabaseRealtimeHandle, type RealtimeChannelLike, type RealtimeChange, type RelationLookup, type RelationLookupConfig, type RelationOption, type SupabaseAuthConfig, type SupabaseAuthController, type SupabaseAuthClientLike, type AuthState, type AuthUser, withEntityRules, withRelationLabels, reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, type AggregateReduce, type AggregateRequest, type AggregateBucket, type AggregateSource, type DashboardSpec, type DashboardWidget, type KpiWidget, type ChartWidget, type RelationLabelConfig, } from './sources';
+export { buildInitialValues, controlKind, editMode, evalValidationRules, fieldState, hasFieldConditions, rowId, stripHiddenValues, toSubmitValues, validateAll, visibleFormFields, type EditMode, type ControlKind, type FieldState, } from './edit-panel';
+export { default as SvGridEditPanel } from './SvGridEditPanel.svelte';
+export { default as SvLookupInput } from './SvLookupInput.svelte';
+export { default as SvFileInput } from './SvFileInput.svelte';
+export { default as SvAuthGate } from './SvAuthGate.svelte';
+export { default as SvSchemaChart } from './SvSchemaChart.svelte';
+export { default as SvSchemaDashboard } from './SvSchemaDashboard.svelte';
+export { default as SvBoard } from './SvBoard.svelte';
+export { default as SvSchedule } from './SvSchedule.svelte';
+export { default as SvRecordDetail } from './SvRecordDetail.svelte';
+export { FIELD_TYPES, blankField, addField, removeField, updateField, moveField, validateSchema, isSchemaValid, sampleRows, type SchemaIssue, type SchemaIssueLevel, } from './schema-designer';
+export { createProject, defaultScreenFor, emitStudioProject, emitStudioAppBundle, emitStudioApp, sampleApps, getSampleApp, starterProject, liveDataSamples, getLiveDataSample, type SampleApp, starterDatasets, getStarterDataset, type StarterDataset, crudSuiteScreens, addCrudSuite, crudAppFromSchemas, type CrudScreenKind, type CrudEditingMode, type CrudSuiteOptions, type CrudAppOptions, introspectJson, sanitizeStudioProject, buildStudioBugReport, type BugReport, type BugReportInput, addBlock, addBlockAt, removeBlock, moveBlock, reorderBlock, updateBlock, addScreen, removeScreen, updateScreen, duplicateScreen, reorderScreen, insertBlock, addEntity, removeEntity, updateEntity, setDataSource, defaultEntitySource, setEntityDataSource, entityDataSource, setTheme, setThemePreset, setShell, sanitizeProject, screenFromTemplate, addScreenFromTemplate, addFreestandingScreen, serializeProject, parseProject, blockPalette, validateProject, isProjectValid, entityOf, studioThemes, defaultStudioTheme, getStudioTheme, resolveThemeTokens, isDarkTheme, themeStyleString, type StudioTheme, type StudioProject, type Screen, type ScreenNav, type Block, type BlockKind, type BlockConfig, type GridConfig, type GridEditing, type GridDensity, type GridAlign, type PagerPosition, type GridColumnConfig, type ChartConfig, type KpiConfig, type KpiFormat, type DashboardConfig, type MasterDetailConfig, type LookupConfig, type Reduce, type DataSourceKind, type EntityDataSource, type MemorySource, type RestSource, type SqlSource, type SupabaseSource, type RestMethod, type ParamLocation, type ParamType, type RequestParam, type SqlDialectKind, type ProjectTheme, type ShellConfig, type ShellStyle, type ScreenTemplate, type PaletteItem, type ProjectIssue, type GeneratedFile, } from './studio';
+export { buildConnectionString, parseConnectionString, redactConnectionString, isFileDialect, DRIVER_PACKAGE, DEFAULT_PORT, countTableRows, probeConnection, type SqlConnectionParts, type TableRowCount, type SqlDialectName, } from './studio';
+export { buildDisplayRows, isDetailRow, toggleExpanded, type DetailRow, } from './master-detail';
+export { default as SvGridMasterDetail } from './SvGridMasterDetail.svelte';
+export { default as SvPivotDesigner } from './SvPivotDesigner.svelte';
+export { ALL_AGGREGATORS, AGG_LABEL, EMPTY_LAYOUT, defaultLayoutFor, type PivotField, type PivotValueChip, type PivotFilterChip, type PivotLayout, type PivotPreset, type Well, } from './pivot-designer';
+export { pivotToChartSpec, type PivotChartOptions } from './pivot-chart';
+export { evaluatePredicate, evaluateScalar, evaluateChange, BUILTIN_FUNCTION_NAMES, isBuiltinFunction, } from './expressions/evaluate';
+export { parsePredicate, stringifyPredicate, stringifyScalar, validateExpression, collectColumnRefs, ExpressionParseError, } from './expressions/parse';
+export { OPERATORS, operatorMeta, operatorsForType, isValueless, isSetOperator, isRangeOperator, columnById, resolveColumnRef, columnLabel, columnRefText, type ExprColumn, type ExprColumnType, type OperatorMeta, } from './expressions/expression-columns';
+export type { ScalarExpr, PredicateExpr, ChangeExpr, ComparisonOp, ArithmeticOp, AggFn, EvalContext, ExprRow, } from './expressions/expression-types';
+export { default as SvExpressionEditor } from './SvExpressionEditor.svelte';
+export { enableAlerts } from './alerts';
+export { createAlertEngine, renderTemplate, type AlertEngine, type AlertEngineOptions, type ValidateEditResult, } from './alerts/alert-engine';
+export { attachAlertEngine, applyAlertEvents, type AlertAttachment, type AttachAlertOptions, type FlashTarget, } from './alerts/alert-engine-attach';
+export { memoryAlertRules, localStorageAlertRules, createAlertRules, type AlertRulesStorage, type AlertRulesManager, } from './alerts/alert-storage';
+export { createAlertObserver, type AlertObserver, type AlertObserverOptions, } from './alerts/alert-observer';
+export { createAlertScheduler, type AlertScheduler, type AlertSchedulerMode, } from './alerts/alert-scheduler';
+export { toConditionalFormats, rulesToConditionalFormats, type StylingContext } from './alerts/alert-formats';
+export { alertStore } from './alerts/alert-store.svelte';
+export type { AlertRule, AlertEvent, AlertTrigger, AlertAction, AlertActionKind, AlertActionStyle, AlertScope, AlertSeverity, } from './alerts/alert-types';
+export { default as SvGridAlerts } from './SvGridAlerts.svelte';
+export { default as SvAlertRuleEditor } from './SvAlertRuleEditor.svelte';
+export { default as SvAlertsManager } from './SvAlertsManager.svelte';
+export { default as SvAlertsPanel } from './SvAlertsPanel.svelte';

package/dist/index.js

@@ -0,0 +1,91 @@
+export { setLicenseKey, clearLicenseKey, getLicenseKey, isLicenseKeySet, hasValidLicense, assertEnterpriseLicensed, nudgeEnterprise, checkLicenseKey, 
+// Trial expiry. The built-in card already appears on its own once a trial
+// lapses; these are for hosts that would rather render their own banner.
+isLicenseExpired, getLicenseExpiry, } from './license';
+export { parseLicenseExpiry } from './license-core';
+export { exportGrid, copyExportToClipboard, } from './export';
+export { default as SvExportMenu } from './SvExportMenu.svelte';
+export { buildPdfDocDefinition } from './export-pdf';
+export { printGrid } from './print';
+export { importData, readImportMatrix, mapImportMatrix, mapImportMatrixAsync, autoMapColumns, inferImportColumnTypes, } from './import';
+export { default as SvImportDialog } from './SvImportDialog.svelte';
+export { installEnterprise } from './install';
+// Scheduler / calendar view (Pro). `enableSchedulerView()` registers the
+// renderer so `<SvGrid scheduler={...}>` shows a Month/Week/Day/Agenda calendar.
+// The pure model helpers + config types live in @svgrid/grid; import them from there.
+export { enableSchedulerView, SvGridScheduler } from './scheduler';
+// Kanban board view (Pro). `enableBoardView()` registers the renderer so
+// `<SvGrid board={...}>` shows lanes of cards. Config types live in @svgrid/grid.
+export { enableBoardView, SvGridBoard } from './board';
+// In-grid pivot mode (Pro). `enablePivot()` registers the pivot engine so
+// `<SvGrid pivot={...}>` renders a pivot table in place of the flat table.
+export { enablePivot } from './pivot-enable';
+export { buildDependencyGraph, topoOrder, hasCycle, requiredStart, cascade, violations, } from './scheduler-dependencies';
+export { expandAssignments, resourceLoad, overallocations, assignedMinutes, } from './scheduler-assignments';
+export { columnSummaries, sumReducer, countReducer, busyMinutesReducer, } from './scheduler-summary';
+export { buildAxis, timeToX, xToTime, resolveZoom, zoomPresets, } from './scheduler-axis';
+export { buildResourceRows, visibleResourceIds, } from './scheduler-resource-tree';
+export { heatCells, heatPeak } from './scheduler-heatmap';
+export { respectsBuffer, withinDurationBounds, afterLead, } from './scheduler-booking';
+export { availableSlots, mergeIntervals, subtractIntervals, } from './scheduler-slots';
+export { mergeBusy, commonFree } from './scheduler-freebusy';
+export { createStagedEditing, } from './staged-editing';
+export { createScheduler, parseCron, cronMatches, cronMatchesParsed, isScheduleDue, nextRun, CRON_PRESETS, } from './scheduling';
+export { dismissUnlicensedNudge } from './watermark';
+export { showUpgradePrompt, dismissUpgradePrompt, } from './upgrade-prompt';
+export { createPivotModel, pivotAggregators, filterCollapsedPivotRows, } from './pivot';
+export { titleCase, resolveIdField, schemaToColumns, schemaToFormFields, validateField, applyComputed, validateEntity, } from './schema';
+export { planQuery, coerce, createInMemoryDataSource, createKitDataSource, createKitHandlers, createSqlDataSource, planToSql, } from './sveltekit';
+export { createSupabaseDataSource, createRestDataSource, offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, introspectSupabaseTable, listSupabaseTables, createSupabaseRealtime, createRelationLookup, createSupabaseAuth, aggregateRows, chartFieldsFromSchema, normalizeFilters, buildEntitySchema, pickLabelField, linkRelationLabels, withEntityRules, withRelationLabels, reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, } from './sources';
+export { buildInitialValues, controlKind, editMode, evalValidationRules, fieldState, hasFieldConditions, rowId, stripHiddenValues, toSubmitValues, validateAll, visibleFormFields, } from './edit-panel';
+export { default as SvGridEditPanel } from './SvGridEditPanel.svelte';
+export { default as SvLookupInput } from './SvLookupInput.svelte';
+export { default as SvFileInput } from './SvFileInput.svelte';
+export { default as SvAuthGate } from './SvAuthGate.svelte';
+export { default as SvSchemaChart } from './SvSchemaChart.svelte';
+export { default as SvSchemaDashboard } from './SvSchemaDashboard.svelte';
+export { default as SvBoard } from './SvBoard.svelte';
+export { default as SvSchedule } from './SvSchedule.svelte';
+export { default as SvRecordDetail } from './SvRecordDetail.svelte';
+export { FIELD_TYPES, blankField, addField, removeField, updateField, moveField, validateSchema, isSchemaValid, sampleRows, } from './schema-designer';
+// NOTE: The visual designer components (SvSchemaDesigner, SvStudioDesigner) are
+// the commercial "SvGrid Studio" seller. They live entirely in the PRIVATE
+// website repo (website/src/lib/designer), NOT in this public package - they
+// import the public API below. The Studio *codegen* below stays public because
+// the MCP server depends on it.
+// The Studio project model + codegen (also on the pure `@svgrid/enterprise/studio`
+// subpath) - re-exported so the designer and its model come from one import.
+export { createProject, defaultScreenFor, emitStudioProject, emitStudioAppBundle, emitStudioApp, sampleApps, getSampleApp, starterProject, liveDataSamples, getLiveDataSample, starterDatasets, getStarterDataset, crudSuiteScreens, addCrudSuite, crudAppFromSchemas, introspectJson, sanitizeStudioProject, buildStudioBugReport, addBlock, addBlockAt, removeBlock, moveBlock, reorderBlock, updateBlock, addScreen, removeScreen, updateScreen, duplicateScreen, reorderScreen, insertBlock, addEntity, removeEntity, updateEntity, setDataSource, defaultEntitySource, setEntityDataSource, entityDataSource, setTheme, setThemePreset, setShell, sanitizeProject, screenFromTemplate, addScreenFromTemplate, addFreestandingScreen, serializeProject, parseProject, blockPalette, validateProject, isProjectValid, entityOf, studioThemes, defaultStudioTheme, getStudioTheme, resolveThemeTokens, isDarkTheme, themeStyleString, } from './studio';
+export { buildConnectionString, parseConnectionString, redactConnectionString, isFileDialect, DRIVER_PACKAGE, DEFAULT_PORT, countTableRows, probeConnection, } from './studio';
+export { buildDisplayRows, isDetailRow, toggleExpanded, } from './master-detail';
+export { default as SvGridMasterDetail } from './SvGridMasterDetail.svelte';
+export { default as SvPivotDesigner } from './SvPivotDesigner.svelte';
+export { ALL_AGGREGATORS, AGG_LABEL, EMPTY_LAYOUT, defaultLayoutFor, } from './pivot-designer';
+// The AI helpers (setAIProvider, aiFilter, aiSmartFill, aiSummarize, aiClassify,
+// aiExport, aiFindAnomalies, aiChart, enableAiCharting, ...) are now BUILT-IN and
+// FREE in @svgrid/grid - import them from there. Enterprise only registers its
+// export engine so AI-planned Excel/PDF exports can run (see install.ts).
+export { pivotToChartSpec } from './pivot-chart';
+// Expression / query language (Pro). One predicate/scalar/change model that
+// powers alerts (and, in time, styled + calculated columns). Leaf comparisons
+// reuse the grid's own `applyExcelFilter`, so operators match the filter row.
+export { evaluatePredicate, evaluateScalar, evaluateChange, BUILTIN_FUNCTION_NAMES, isBuiltinFunction, } from './expressions/evaluate';
+export { parsePredicate, stringifyPredicate, stringifyScalar, validateExpression, collectColumnRefs, ExpressionParseError, } from './expressions/parse';
+export { OPERATORS, operatorMeta, operatorsForType, isValueless, isSetOperator, isRangeOperator, columnById, resolveColumnRef, columnLabel, columnRefText, } from './expressions/expression-columns';
+export { default as SvExpressionEditor } from './SvExpressionEditor.svelte';
+// Alert Rules engine (Pro). Declarative "when this holds / this moves -> toast /
+// badge / highlight / flash / prevent-edit / log". Authored at runtime,
+// persisted, shareable. Surfacing reuses the grid's toast + conditional-format
+// engines; `<SvGridAlerts>` is the runtime overlay the consumer mounts.
+export { enableAlerts } from './alerts';
+export { createAlertEngine, renderTemplate, } from './alerts/alert-engine';
+export { attachAlertEngine, applyAlertEvents, } from './alerts/alert-engine-attach';
+export { memoryAlertRules, localStorageAlertRules, createAlertRules, } from './alerts/alert-storage';
+export { createAlertObserver, } from './alerts/alert-observer';
+export { createAlertScheduler, } from './alerts/alert-scheduler';
+export { toConditionalFormats, rulesToConditionalFormats } from './alerts/alert-formats';
+export { alertStore } from './alerts/alert-store.svelte';
+export { default as SvGridAlerts } from './SvGridAlerts.svelte';
+export { default as SvAlertRuleEditor } from './SvAlertRuleEditor.svelte';
+export { default as SvAlertsManager } from './SvAlertsManager.svelte';
+export { default as SvAlertsPanel } from './SvAlertsPanel.svelte';

package/dist/install.d.ts

@@ -0,0 +1,70 @@
+import type { RowData, TableFeatures, SvGridApi } from '@svgrid/grid';
+import { type ExportOptions, type ExportResult, type ClipboardExportOptions } from './export';
+import { type PrintOptions } from './print';
+import { type ImportOptions, type ImportResult } from './import';
+import { type AIChartOptions, type AIChartPlan, type AIFilterOptions, type AIFilterResult, type AISmartFillOptions, type AISmartFillResult, type AISummarizeOptions, type AISummary, type AIClassifyOptions, type AIClassifyResult, type AIExportOptions, type AIExportPlan, type AIAnomalyOptions, type AIAnomalyResult } from '@svgrid/grid';
+import { type PivotConfig, type PivotResult } from './pivot';
+export type EnterpriseAIApi<TData extends RowData> = {
+    /** Natural-language -> filter + sort plan (and optionally apply it). */
+    filter(query: string, opts?: AIFilterOptions): Promise<AIFilterResult>;
+    /** Propose values for empty cells based on a few worked examples. */
+    smartFill<TValue = unknown>(opts: AISmartFillOptions): Promise<AISmartFillResult<TValue>>;
+    /** One-paragraph + bullets summary of a row, selection, group, or the whole view. */
+    summarize(opts: AISummarizeOptions): Promise<AISummary>;
+    /** Classify free-text cells into one of a known set of labels. */
+    classify(opts: AIClassifyOptions): Promise<AIClassifyResult>;
+    /** Natural-language export: "export EU orders from Q2 as a grouped PDF". */
+    export(query: string, opts?: AIExportOptions): Promise<AIExportPlan>;
+    /** Scan a slice for anomalies / outliers, returning a structured list. */
+    findAnomalies(opts?: AIAnomalyOptions): Promise<AIAnomalyResult>;
+    /** Natural-language chart: "revenue by region, stacked by product". */
+    chart(query: string, opts?: AIChartOptions): Promise<AIChartPlan>;
+    readonly _rowType?: TData;
+};
+export type EnterprisePivotApi<TFeatures extends TableFeatures, TData extends RowData> = {
+    /**
+     * Build a pivot row/column model from the grid's current data. Returns
+     * `{ rows, columns }` you can feed to a separate `<SvGrid>` instance
+     * (the typical pattern - the source grid stays unmodified). Pure: no
+     * mutation, no DOM access.
+     */
+    build(config: PivotConfig<TData>): PivotResult<TFeatures>;
+    /**
+     * Build a pivot from an arbitrary array (not necessarily the grid's
+     * data). Useful for previewing a designer's config against a sample
+     * before committing.
+     */
+    buildFrom<TIn extends RowData>(data: ReadonlyArray<TIn>, config: PivotConfig<TIn>): PivotResult<TFeatures>;
+};
+export type EnterpriseGridApi<TFeatures extends TableFeatures, TData extends RowData> = SvGridApi<TFeatures, TData> & {
+    /** Export the current visible rows to the chosen format. Returns the built
+     *  file ({@link ExportResult}) for the dependency-free paths (undefined for
+     *  the vendored-writer xlsx paths, which download directly). */
+    exportData(opts: ExportOptions<TData>): Promise<ExportResult | undefined>;
+    /** Copy the grid (view / selection / all) to the clipboard in a native text
+     *  format (default `tsv`, pastes into Excel / Sheets as columns). */
+    copyExport(opts?: ClipboardExportOptions<TData>): Promise<void>;
+    /** Open a printable view of the current visible rows in a new window. */
+    print(opts?: PrintOptions<TData>): Promise<void>;
+    /** Read an Excel / CSV / TSV / JSON file (or inline text) into typed
+     *  rows. Caller decides whether to commit into the grid or preview
+     *  the parsed result first via the returned `ImportResult`. */
+    importData(opts: ImportOptions<TData>): Promise<ImportResult<TData>>;
+    /** AI helpers (Pro). All calls route through a consumer-registered
+     *  AIProvider via setAIProvider(); no model client is bundled. */
+    ai: EnterpriseAIApi<TData>;
+    /** Pivot table builder (Pro). Pure - returns `{ rows, columns }` you
+     *  hand to a separate `<SvGrid>` instance. */
+    pivot: EnterprisePivotApi<TFeatures, TData>;
+};
+/**
+ * Augment a SvGridApi instance with Pro methods (`exportData`, `print`,
+ * `ai.*`). Mutates and returns the same object so existing references
+ * keep working.
+ *
+ * If no license key has been set, the Pro methods still function but the
+ * grid shows a small "unlicensed" watermark linking to jqwidgets.com and
+ * the console emits a one-time nudge. Revoked or malformed keys throw on
+ * first call.
+ */
+export declare function installEnterprise<TFeatures extends TableFeatures, TData extends RowData>(api: SvGridApi<TFeatures, TData>): EnterpriseGridApi<TFeatures, TData>;

package/dist/install.js

@@ -0,0 +1,61 @@
+import { exportGrid, copyExportToClipboard, } from './export';
+import { printGrid } from './print';
+import { importData } from './import';
+import { isLicenseKeySet } from './license';
+import { emitUnlicensedNudge } from './watermark';
+// AI helpers are built-in + free in @svgrid/grid now; enterprise just wires them
+// into the Pro API and registers its export engine so AI exports can write xlsx/pdf.
+import { aiFilter, aiSmartFill, aiSummarize, aiClassify, aiExport, aiFindAnomalies, aiChart, enableAiCharting, registerExportProvider, } from '@svgrid/grid';
+import { createPivotModel, } from './pivot';
+import { enableSchedulerView } from './scheduler';
+import { enableBoardView } from './board';
+import { enablePivot } from './pivot-enable';
+/**
+ * Augment a SvGridApi instance with Pro methods (`exportData`, `print`,
+ * `ai.*`). Mutates and returns the same object so existing references
+ * keep working.
+ *
+ * If no license key has been set, the Pro methods still function but the
+ * grid shows a small "unlicensed" watermark linking to jqwidgets.com and
+ * the console emits a one-time nudge. Revoked or malformed keys throw on
+ * first call.
+ */
+export function installEnterprise(api) {
+    const pro = api;
+    pro.exportData = (opts) => exportGrid(pro, opts);
+    pro.copyExport = (opts) => copyExportToClipboard(pro, opts);
+    pro.print = (opts) => printGrid(pro, opts);
+    pro.importData = (opts) => importData(pro, opts);
+    pro.ai = {
+        filter: (query, opts) => aiFilter(pro, query, opts),
+        smartFill: (opts) => aiSmartFill(pro, opts),
+        summarize: (opts) => aiSummarize(pro, opts),
+        classify: (opts) => aiClassify(pro, opts),
+        export: (query, opts) => aiExport(pro, query, opts),
+        findAnomalies: (opts) => aiFindAnomalies(pro, opts),
+        chart: (query, opts) => aiChart(pro, query, opts),
+    };
+    // Wire the built-in chart panel's AI button (no-op without the `charting` prop).
+    enableAiCharting(pro);
+    // Register the scheduler / calendar view (no-op without the `scheduler` prop).
+    enableSchedulerView();
+    // Register the Kanban board view (no-op without the `board` prop).
+    enableBoardView();
+    // Register the export engine so built-in AI exports (aiExport) can write the
+    // enterprise formats (xlsx / pdf / ...); free grids without it get the plan only.
+    registerExportProvider(exportGrid);
+    enablePivot();
+    pro.pivot = {
+        build: (config) => createPivotModel(pro.getData(), config),
+        buildFrom: (data, config) => 
+        // PivotConfig is variance-strict in TIn; the runtime call only needs
+        // the row shape to match config.rows / config.cols field names, which
+        // the caller-side generic enforces.
+        createPivotModel(data, config),
+    };
+    // Surface the soft-gate state at install time so the watermark appears
+    // alongside the grid, not just after the user clicks Export.
+    if (!isLicenseKeySet())
+        emitUnlicensedNudge();
+    return pro;
+}

package/dist/license-core.d.ts

@@ -0,0 +1,37 @@
+export declare const VALID_PREFIX = "SVENTERPRISE-";
+export type LicenseStatus = 'unset' | 'invalid' | 'revoked' | 'dev' | 'eval' | 'licensed';
+export type LicenseInfo = {
+    status: LicenseStatus;
+    /** True when the key permits use (dev / eval / licensed). */
+    valid: boolean;
+    /** Expiry encoded in the key, when it carries one. Undefined otherwise. */
+    expiresAt?: Date;
+    /**
+     * True once `expiresAt` has passed. Deliberately does NOT clear `valid`:
+     * an expired trial keeps working and the callers nudge instead. Turning a
+     * lapsed key into a hard stop would break a running app on a date boundary,
+     * which is exactly what a soft gate exists to avoid.
+     */
+    expired?: boolean;
+};
+/**
+ * Pull the expiry out of a key.
+ *
+ * Keys are `SVENTERPRISE[-KIND]-<SLUG>-<SEATS>-<DATE>-<RANDOM>`, so the date is
+ * always the second-to-last segment regardless of whether a KIND is present.
+ * Two widths are accepted:
+ *
+ *   YYYYMM   - subscription granularity; expires at the end of that month.
+ *   YYYYMMDD - trial granularity; expires at the end of that day.
+ *
+ * The 6-digit form came first, so every key issued before day-precision trials
+ * existed still parses. Anything else (including the older keys whose slug sits
+ * in that position) yields null, which reads as "no expiry encoded".
+ *
+ * Boundaries are UTC so a key does not lapse at a different instant per
+ * timezone. Kept in sync with `tools/issue-license.mjs`.
+ */
+export declare function parseLicenseExpiry(key: string | null | undefined): Date | null;
+/** Classify a license key string. Pure and side-effect-free.
+ *  `now` is injectable so expiry behaviour is testable without faking clocks. */
+export declare function checkLicenseKey(key: string | null | undefined, now?: Date): LicenseInfo;

package/dist/license-core.js

@@ -0,0 +1,81 @@
+// Pure license classification - no DOM, no Svelte, no module state. Shared by
+// the browser gate (license.ts, via setLicenseKey) AND the Node/MCP generator
+// (which reads the key from the SVGRID_LICENSE_KEY env var). One definition of
+// "what a valid key is," so the two contexts can never drift.
+//
+// This is deliberately NOT crypto (see license.ts). It classifies a key string;
+// callers decide what to do with the result. The Studio is soft-gate only:
+// unlicensed use still works, it just nudges.
+import { REVOKED_KEYS } from './revoked.js';
+export const VALID_PREFIX = 'SVENTERPRISE-';
+/**
+ * Pull the expiry out of a key.
+ *
+ * Keys are `SVENTERPRISE[-KIND]-<SLUG>-<SEATS>-<DATE>-<RANDOM>`, so the date is
+ * always the second-to-last segment regardless of whether a KIND is present.
+ * Two widths are accepted:
+ *
+ *   YYYYMM   - subscription granularity; expires at the end of that month.
+ *   YYYYMMDD - trial granularity; expires at the end of that day.
+ *
+ * The 6-digit form came first, so every key issued before day-precision trials
+ * existed still parses. Anything else (including the older keys whose slug sits
+ * in that position) yields null, which reads as "no expiry encoded".
+ *
+ * Boundaries are UTC so a key does not lapse at a different instant per
+ * timezone. Kept in sync with `tools/issue-license.mjs`.
+ */
+export function parseLicenseExpiry(key) {
+    if (!key)
+        return null;
+    const segments = key.split('-');
+    if (segments.length < 3)
+        return null;
+    const stamp = segments[segments.length - 2];
+    if (stamp == null)
+        return null;
+    if (/^\d{6}$/.test(stamp)) {
+        const year = Number(stamp.slice(0, 4));
+        const month = Number(stamp.slice(4, 6));
+        if (month < 1 || month > 12)
+            return null;
+        // Date.UTC's month is 0-based, so passing the 1-based month lands on the
+        // first of the FOLLOWING month; one millisecond earlier is the last instant
+        // of the month the key names.
+        return new Date(Date.UTC(year, month, 1) - 1);
+    }
+    if (/^\d{8}$/.test(stamp)) {
+        const year = Number(stamp.slice(0, 4));
+        const month = Number(stamp.slice(4, 6));
+        const day = Number(stamp.slice(6, 8));
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            return null;
+        const end = new Date(Date.UTC(year, month - 1, day, 23, 59, 59, 999));
+        // Reject a date that rolled over (e.g. 20260231), which would otherwise
+        // silently grant a few extra days.
+        if (end.getUTCMonth() !== month - 1)
+            return null;
+        return end;
+    }
+    return null;
+}
+/** Classify a license key string. Pure and side-effect-free.
+ *  `now` is injectable so expiry behaviour is testable without faking clocks. */
+export function checkLicenseKey(key, now = new Date()) {
+    if (key == null || key === '')
+        return { status: 'unset', valid: false };
+    if (!key.startsWith(VALID_PREFIX))
+        return { status: 'invalid', valid: false };
+    if (REVOKED_KEYS.has(key))
+        return { status: 'revoked', valid: false };
+    const expiresAt = parseLicenseExpiry(key) ?? undefined;
+    // Left undefined rather than false when the key encodes no date, so callers
+    // can tell "not expired" apart from "no expiry to check".
+    const expired = expiresAt ? now.getTime() > expiresAt.getTime() : undefined;
+    const status = key.startsWith('SVENTERPRISE-DEV')
+        ? 'dev'
+        : key.startsWith('SVENTERPRISE-EVAL')
+            ? 'eval'
+            : 'licensed';
+    return { status, valid: true, expiresAt, expired };
+}

package/dist/license.d.ts

@@ -0,0 +1,30 @@
+import { type EnterpriseFeatureLabel } from './upgrade-prompt';
+export { checkLicenseKey, type LicenseInfo, type LicenseStatus } from './license-core';
+export declare function setLicenseKey(key: string): void;
+export declare function clearLicenseKey(): void;
+export declare function getLicenseKey(): string | null;
+/** True if a key is set at all (regardless of validity). */
+export declare function isLicenseKeySet(): boolean;
+/**
+ * True if the current key passes every check: present, valid prefix, not
+ * revoked. Use this from callers that want to branch on license status
+ * (e.g. UI that hides Pro-only options when unlicensed).
+ */
+export declare function hasValidLicense(): boolean;
+/**
+ * True when the current key encoded an expiry that has passed. The feature set
+ * still runs - this exists so a host can show its own banner rather than rely
+ * on the built-in card. Returns false when the key carries no expiry.
+ */
+export declare function isLicenseExpired(): boolean;
+/** When the current key lapses, or null if it encodes no expiry. */
+export declare function getLicenseExpiry(): Date | null;
+/**
+ * Soft-gate a Pro surface: if the current key isn't valid, nudge (watermark +
+ * one-time console log + a moment-of-intent upgrade card naming `feature`) and
+ * return. NEVER throws and NEVER blocks - the feature always runs. This is the
+ * gate the Studio uses, and it's safe to call on the server (the nudges no-op
+ * without a DOM). Idempotent/self-throttling, so call it freely at chokepoints.
+ */
+export declare function nudgeEnterprise(feature?: EnterpriseFeatureLabel): void;
+export declare function assertEnterpriseLicensed(feature?: EnterpriseFeatureLabel): void;

package/dist/license.js

@@ -0,0 +1,139 @@
+// Polite license gate. Not crypto - anyone with devtools can extract the key
+// from a deployed bundle. The point is to make commercial use require a
+// transaction, not to defeat reverse engineering.
+//
+// Behavior matrix:
+//
+//   currentKey state                  -> result
+//   ────────────────────────────────────────────────────────────────────
+//   null (no key set)                 -> soft-gate: watermark + console.log,
+//                                        feature still runs
+//   does not start with "SVENTERPRISE-"      -> throws (programmer error)
+//   in REVOKED_KEYS                   -> throws (revoked / leaked / expired)
+//   starts with "SVENTERPRISE-DEV" or
+//     "SVENTERPRISE-EVAL"                    -> works; one-time console.info notice
+//   an EXPIRED dev/eval key            -> still works, but stops looking
+//                                        licensed: watermark + a one-time
+//                                        console notice naming the expiry date
+//                                        + the upgrade card. Stays a soft gate
+//                                        so a trial ending cannot break a build.
+//   any other "SVENTERPRISE-..."             -> works silently (paid production)
+import { checkLicenseKey, VALID_PREFIX } from './license-core';
+import { emitUnlicensedNudge } from './watermark';
+import { showUpgradePrompt } from './upgrade-prompt';
+export { checkLicenseKey } from './license-core';
+let currentKey = null;
+let noticedDev = false;
+let noticedExpired = false;
+/** One-time console notice for a trial that has run out. Separate from the
+ *  dev/eval notice: that one says "not for production", this one says the
+ *  evaluation is over and names the date, which is the actionable part. */
+function noticeExpired(info) {
+    if (noticedExpired)
+        return;
+    noticedExpired = true;
+    const on = info.expiresAt ? ` on ${info.expiresAt.toISOString().slice(0, 10)}` : '';
+    // eslint-disable-next-line no-console
+    console.info(`@svgrid/enterprise: your evaluation license expired${on}. Everything still ` +
+        'works, but the watermark and upgrade notice stay until a license key is set. ' +
+        'Contact sales@jqwidgets.com or see https://svgrid.com/pricing');
+}
+export function setLicenseKey(key) {
+    if (typeof key !== 'string' || key.length === 0) {
+        throw new Error('@svgrid/enterprise: setLicenseKey() requires a non-empty string');
+    }
+    currentKey = key;
+    noticedDev = false;
+    noticedExpired = false;
+}
+export function clearLicenseKey() {
+    currentKey = null;
+    noticedDev = false;
+    noticedExpired = false;
+}
+export function getLicenseKey() {
+    return currentKey;
+}
+/** True if a key is set at all (regardless of validity). */
+export function isLicenseKeySet() {
+    return currentKey != null;
+}
+/**
+ * True if the current key passes every check: present, valid prefix, not
+ * revoked. Use this from callers that want to branch on license status
+ * (e.g. UI that hides Pro-only options when unlicensed).
+ */
+export function hasValidLicense() {
+    return checkLicenseKey(currentKey).valid;
+}
+/**
+ * True when the current key encoded an expiry that has passed. The feature set
+ * still runs - this exists so a host can show its own banner rather than rely
+ * on the built-in card. Returns false when the key carries no expiry.
+ */
+export function isLicenseExpired() {
+    return checkLicenseKey(currentKey).expired === true;
+}
+/** When the current key lapses, or null if it encodes no expiry. */
+export function getLicenseExpiry() {
+    return checkLicenseKey(currentKey).expiresAt ?? null;
+}
+/**
+ * Soft-gate a Pro surface: if the current key isn't valid, nudge (watermark +
+ * one-time console log + a moment-of-intent upgrade card naming `feature`) and
+ * return. NEVER throws and NEVER blocks - the feature always runs. This is the
+ * gate the Studio uses, and it's safe to call on the server (the nudges no-op
+ * without a DOM). Idempotent/self-throttling, so call it freely at chokepoints.
+ */
+export function nudgeEnterprise(feature) {
+    const info = checkLicenseKey(currentKey);
+    // `valid` stays true past a trial's expiry (the feature keeps running), so
+    // checking it alone would let a lapsed trial through silently forever.
+    if (info.valid && !info.expired)
+        return;
+    const lapsedTrial = info.valid && info.expired === true;
+    // A lapsed trial gets the same treatment as an unlicensed app - watermark,
+    // console notice and card. The evaluation is over; the app keeps running,
+    // but it stops looking licensed.
+    emitUnlicensedNudge();
+    if (lapsedTrial)
+        noticeExpired(info);
+    showUpgradePrompt(feature, { expired: lapsedTrial });
+}
+export function assertEnterpriseLicensed(feature) {
+    const info = checkLicenseKey(currentKey);
+    switch (info.status) {
+        case 'unset':
+            // Soft-gate: the feature still runs, but the user gets a watermark +
+            // a one-time console.log nudge directing them to pricing, plus a
+            // contextual moment-of-intent upgrade card naming the feature they
+            // just reached for.
+            emitUnlicensedNudge();
+            showUpgradePrompt(feature);
+            return;
+        case 'invalid':
+            throw new Error(`@svgrid/enterprise: invalid license key format (expected "${VALID_PREFIX}..." prefix).`);
+        case 'revoked':
+            throw new Error('@svgrid/enterprise: this license key has been revoked. ' +
+                'Contact sales@jqwidgets.com for a replacement.');
+        case 'dev':
+        case 'eval':
+            if (info.expired) {
+                // The trial is over. Deliberately NOT a throw: the app keeps working,
+                // so the developer sees the nudges without their users hitting a broken
+                // build. Watermark + console notice + card, same as an unlicensed app.
+                emitUnlicensedNudge();
+                noticeExpired(info);
+                showUpgradePrompt(feature, { expired: true });
+                return;
+            }
+            if (!noticedDev) {
+                // eslint-disable-next-line no-console
+                console.info('@svgrid/enterprise: using a development / evaluation license. Not for production use.');
+                noticedDev = true;
+            }
+            return;
+        case 'licensed':
+            return;
+    }
+}

package/dist/master-detail.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Master-detail logic. The testable core behind `SvGridMasterDetail.svelte`:
+ * track which parent rows are expanded and splice a synthetic "detail" row in
+ * after each expanded parent, so a single `<SvGrid>` renders both the master
+ * rows and a full-width detail region (via the grid's `isDetailRow` /
+ * `renderDetailRow`). Pure - no Svelte, no DOM.
+ */
+/** A synthetic row inserted after an expanded parent; carries the parent it belongs to. */
+export type DetailRow<TParent> = {
+    __svgridDetail: true;
+    parent: TParent;
+    parentId: string;
+};
+/** True for the synthetic detail rows produced by `buildDisplayRows`. */
+export declare function isDetailRow(row: unknown): row is DetailRow<unknown>;
+/** Toggle a parent id in the expanded set, returning a new set (immutable). */
+export declare function toggleExpanded(expanded: ReadonlySet<string>, id: string): Set<string>;
+/**
+ * Weave detail rows into the master rows: each expanded parent is followed by a
+ * `DetailRow` marker. Order is otherwise preserved, so the grid renders parents
+ * in place with their detail region directly beneath.
+ */
+export declare function buildDisplayRows<TParent>(parents: ReadonlyArray<TParent>, expanded: ReadonlySet<string>, getRowId: (parent: TParent) => string): Array<TParent | DetailRow<TParent>>;