@dinoxx/dinox-cli 2.2.0 → 2.3.0

package/dist/vendor/electron/shared/saved-views.js

@@ -0,0 +1,981 @@
+// Generated by scripts/sync-electron-domain.ts from dinox-electron/packages/shared/src/saved-views.ts. Do not edit manually.
+import { z } from 'zod';
+import { isPropertyKeyValid, } from './note-properties.js';
+export const SAVED_VIEW_DISPLAY_ONLY_SYSTEM_FIELDS = [
+    'cover',
+    'audio',
+    'video',
+    'file',
+];
+export const SAVED_VIEW_SYSTEM_FIELDS = [
+    'title',
+    'created_at',
+    'updated_at',
+    'tags',
+    'zettel_boxes',
+    'source',
+    'type',
+    'primary_resource_type',
+    'starred_at',
+    'images',
+    ...SAVED_VIEW_DISPLAY_ONLY_SYSTEM_FIELDS,
+];
+/** Host note id. Valid only as a `$self` value source, never as a column. */
+export const SAVED_VIEW_SELF_ID_FIELD = 'sys.id';
+export const SAVED_VIEW_PRIMARY_RESOURCE_TYPES = [
+    'audio',
+    'video',
+    'file',
+    'image',
+];
+const savedViewSystemFieldRefs = new Set(SAVED_VIEW_SYSTEM_FIELDS.map((field) => `sys.${field}`));
+const savedViewDisplayOnlyFieldRefs = new Set(SAVED_VIEW_DISPLAY_ONLY_SYSTEM_FIELDS.map((field) => `sys.${field}`));
+export function isSavedViewDisplayOnlyField(field) {
+    return savedViewDisplayOnlyFieldRefs.has(field);
+}
+export function isSavedViewFieldRef(value) {
+    if (typeof value !== 'string')
+        return false;
+    if (savedViewSystemFieldRefs.has(value))
+        return true;
+    return value.startsWith('prop.') && isPropertyKeyValid(value.slice('prop.'.length));
+}
+export function isSavedViewSelfSourceFieldRef(value) {
+    return value === SAVED_VIEW_SELF_ID_FIELD || isSavedViewFieldRef(value);
+}
+export const savedViewFieldRefSchema = z.custom(isSavedViewFieldRef, 'Invalid saved view field reference');
+export const SAVED_VIEW_FILTER_OPERATORS = [
+    'equals',
+    'notEquals',
+    'contains',
+    'notContains',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'isEmpty',
+    'isNotEmpty',
+    'withinLastDays',
+    'isToday',
+    'isThisWeek',
+    'isThisMonth',
+];
+export const MAX_SAVED_VIEW_RELATIVE_DAYS = 3650;
+export const SAVED_VIEW_DYNAMIC_DATE_FILTER_OPERATORS = [
+    'withinLastDays',
+    'isToday',
+    'isThisWeek',
+    'isThisMonth',
+];
+const savedViewDynamicDateFilterOperators = new Set(SAVED_VIEW_DYNAMIC_DATE_FILTER_OPERATORS);
+export function isSavedViewDynamicDateFilterOperator(operator) {
+    return savedViewDynamicDateFilterOperators.has(operator);
+}
+const TEXT_FILTER_OPERATORS = [
+    'equals',
+    'notEquals',
+    'contains',
+    'notContains',
+    'isEmpty',
+    'isNotEmpty',
+];
+const ORDERED_FILTER_OPERATORS = [
+    'equals',
+    'notEquals',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'isEmpty',
+    'isNotEmpty',
+];
+const DATE_FILTER_OPERATORS = [
+    'withinLastDays',
+    'isToday',
+    'isThisWeek',
+    'isThisMonth',
+    ...ORDERED_FILTER_OPERATORS,
+];
+const LIST_FILTER_OPERATORS = [
+    'contains',
+    'notContains',
+    'isEmpty',
+    'isNotEmpty',
+];
+const SELECT_FILTER_OPERATORS = [
+    'equals',
+    'notEquals',
+    'isEmpty',
+    'isNotEmpty',
+];
+export function getSavedViewFilterOperatorsForPropertyType(type) {
+    if (type === 'files' || type === 'place')
+        return ['isEmpty', 'isNotEmpty'];
+    if (type === 'checkbox' ||
+        type === 'select' ||
+        type === 'status' ||
+        type === 'relation') {
+        return SELECT_FILTER_OPERATORS;
+    }
+    if (type === 'multi_select')
+        return LIST_FILTER_OPERATORS;
+    if (type === 'date')
+        return DATE_FILTER_OPERATORS;
+    if (type === 'number' || type === 'unique_id')
+        return ORDERED_FILTER_OPERATORS;
+    return TEXT_FILTER_OPERATORS;
+}
+const PRESENCE_FILTER_OPERATORS = ['isNotEmpty', 'isEmpty'];
+export function getSavedViewFilterOperatorsForField(field, type) {
+    if (isSavedViewDisplayOnlyField(field))
+        return [];
+    if (field === 'sys.starred_at' || field === 'sys.images') {
+        return PRESENCE_FILTER_OPERATORS;
+    }
+    if (field === 'sys.primary_resource_type') {
+        return ['equals', 'notEquals', 'isEmpty', 'isNotEmpty'];
+    }
+    return getSavedViewFilterOperatorsForPropertyType(type);
+}
+export function canSortSavedViewPropertyType(type) {
+    return (type !== 'multi_select' &&
+        type !== 'relation' &&
+        type !== 'files' &&
+        type !== 'place');
+}
+export function canSortSavedViewField(field, type) {
+    return (field !== 'sys.starred_at' &&
+        field !== 'sys.primary_resource_type' &&
+        field !== 'sys.images' &&
+        !isSavedViewDisplayOnlyField(field) &&
+        canSortSavedViewPropertyType(type));
+}
+export function dedupeSavedViewFieldRefs(fields) {
+    return [...new Set(fields)];
+}
+export function normalizeSavedViewColumnFieldRefs(fields) {
+    return [
+        'sys.title',
+        ...dedupeSavedViewFieldRefs(fields).filter(field => field !== 'sys.title'),
+    ];
+}
+const MAX_SAVED_VIEW_FILTER_DEPTH = 8;
+const MAX_SAVED_VIEW_FILTER_NODES = 100;
+const MAX_SAVED_VIEW_FILTER_VALUE_LENGTH = 2000;
+const savedViewFilterValueSchema = z.union([
+    z.string().max(MAX_SAVED_VIEW_FILTER_VALUE_LENGTH),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
+const SAVED_VIEW_VALUE_REQUIRED_OPERATORS = new Set([
+    'contains',
+    'notContains',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'withinLastDays',
+]);
+const SAVED_VIEW_VALUELESS_OPERATORS = new Set([
+    'isEmpty',
+    'isNotEmpty',
+    'isToday',
+    'isThisWeek',
+    'isThisMonth',
+]);
+const SELF_VALUE_BLOCKED_CONDITION_FIELDS = new Set([
+    'sys.starred_at',
+    'sys.primary_resource_type',
+    'sys.zettel_boxes',
+    'sys.images',
+]);
+export function isSavedViewSelfValueRef(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return record.kind === 'self' && isSavedViewSelfSourceFieldRef(record.field);
+}
+export function canSavedViewFilterConditionUseSelfValue(field, operator) {
+    if (SAVED_VIEW_VALUELESS_OPERATORS.has(operator) || operator === 'withinLastDays') {
+        return false;
+    }
+    if (isSavedViewDisplayOnlyField(field) || SELF_VALUE_BLOCKED_CONDITION_FIELDS.has(field)) {
+        return false;
+    }
+    return true;
+}
+export function canSavedViewSelfSourceField(field) {
+    if (field === SAVED_VIEW_SELF_ID_FIELD)
+        return true;
+    if (!isSavedViewFieldRef(field) || isSavedViewDisplayOnlyField(field))
+        return false;
+    return field !== 'sys.primary_resource_type' && field !== 'sys.images';
+}
+const savedViewSelfValueRefSchema = z.object({
+    kind: z.literal('self'),
+    field: z.custom(isSavedViewSelfSourceFieldRef, 'Invalid saved view self source field reference'),
+});
+export const savedViewFilterConditionSchema = z
+    .object({
+    kind: z.literal('condition'),
+    field: savedViewFieldRefSchema,
+    operator: z.enum(SAVED_VIEW_FILTER_OPERATORS),
+    value: savedViewFilterValueSchema.optional(),
+    valueRef: savedViewSelfValueRefSchema.optional(),
+})
+    .superRefine((condition, context) => {
+    if (condition.field === 'sys.primary_resource_type') {
+        const comparesValue = condition.operator === 'equals' || condition.operator === 'notEquals';
+        const allowedPresence = condition.operator === 'isEmpty' || condition.operator === 'isNotEmpty';
+        if ((!comparesValue && !allowedPresence) ||
+            (comparesValue &&
+                !SAVED_VIEW_PRIMARY_RESOURCE_TYPES.some((option) => option === condition.value))) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['value'],
+                message: 'Invalid primary resource type filter',
+            });
+        }
+    }
+    const hasSelfValue = isSavedViewSelfValueRef(condition.valueRef);
+    const hasLiteralValue = condition.value !== undefined && condition.value !== null;
+    if (hasSelfValue && hasLiteralValue) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['valueRef'],
+            message: 'Saved view condition cannot combine a literal value with a self value ref',
+        });
+    }
+    if (hasSelfValue) {
+        if (!canSavedViewFilterConditionUseSelfValue(condition.field, condition.operator)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['valueRef'],
+                message: `Saved view operator ${condition.operator} does not accept a self value`,
+            });
+        }
+        if (condition.valueRef && !canSavedViewSelfSourceField(condition.valueRef.field)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['valueRef', 'field'],
+                message: `${condition.valueRef.field} cannot be used as a self filter value`,
+            });
+        }
+    }
+    if (SAVED_VIEW_VALUE_REQUIRED_OPERATORS.has(condition.operator) &&
+        !hasSelfValue &&
+        !hasLiteralValue) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['value'],
+            message: `Saved view operator ${condition.operator} requires a value`,
+        });
+    }
+    if (SAVED_VIEW_VALUE_REQUIRED_OPERATORS.has(condition.operator) &&
+        !hasSelfValue &&
+        typeof condition.value === 'string' &&
+        condition.value.trim().length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['value'],
+            message: `Saved view operator ${condition.operator} requires a non-empty value`,
+        });
+    }
+    if (SAVED_VIEW_VALUELESS_OPERATORS.has(condition.operator) &&
+        (hasLiteralValue || hasSelfValue)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: hasSelfValue ? ['valueRef'] : ['value'],
+            message: `Saved view operator ${condition.operator} does not accept a value`,
+        });
+    }
+    if (condition.operator === 'withinLastDays' &&
+        (typeof condition.value !== 'number' ||
+            !Number.isInteger(condition.value) ||
+            condition.value < 1 ||
+            condition.value > MAX_SAVED_VIEW_RELATIVE_DAYS)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['value'],
+            message: `Saved view operator withinLastDays requires an integer from 1 to ${MAX_SAVED_VIEW_RELATIVE_DAYS}`,
+        });
+    }
+});
+function isRawFilterNodeWithinLimits(value) {
+    const stack = [{ value, depth: 1 }];
+    const seen = new Set();
+    let count = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        if (!current.value ||
+            typeof current.value !== 'object' ||
+            Array.isArray(current.value)) {
+            continue;
+        }
+        if (seen.has(current.value))
+            return false;
+        seen.add(current.value);
+        count += 1;
+        if (count > MAX_SAVED_VIEW_FILTER_NODES || current.depth > MAX_SAVED_VIEW_FILTER_DEPTH) {
+            return false;
+        }
+        const record = current.value;
+        if (record.kind === 'not') {
+            stack.push({ value: record.child, depth: current.depth + 1 });
+        }
+        else if (record.kind === 'group' && Array.isArray(record.children)) {
+            for (const child of record.children) {
+                stack.push({ value: child, depth: current.depth + 1 });
+            }
+        }
+    }
+    return true;
+}
+const invalidSavedViewFilterNode = { kind: '__invalid_saved_view_filter__' };
+export const savedViewFilterNodeSchema = z.preprocess((value) => (isRawFilterNodeWithinLimits(value) ? value : invalidSavedViewFilterNode), z.lazy(() => z.union([
+    savedViewFilterConditionSchema,
+    z.object({
+        kind: z.literal('group'),
+        operator: z.enum(['and', 'or']),
+        children: z.array(savedViewFilterNodeSchema).max(MAX_SAVED_VIEW_FILTER_NODES),
+    }),
+    z.object({
+        kind: z.literal('not'),
+        child: savedViewFilterNodeSchema,
+    }),
+])));
+export const savedViewFilterGroupSchema = z.object({
+    kind: z.literal('group'),
+    operator: z.enum(['and', 'or']),
+    children: z.array(savedViewFilterNodeSchema).max(100),
+});
+function inspectSavedViewFilterNode(node, depth, state) {
+    state.count += 1;
+    state.maxDepth = Math.max(state.maxDepth, depth);
+    if (node.kind === 'group') {
+        for (const child of node.children) {
+            inspectSavedViewFilterNode(child, depth + 1, state);
+        }
+    }
+    else if (node.kind === 'not') {
+        inspectSavedViewFilterNode(node.child, depth + 1, state);
+    }
+}
+export function savedViewFilterNodeUsesDynamicDate(node) {
+    if (!node)
+        return false;
+    if (node.kind === 'condition') {
+        return isSavedViewDynamicDateFilterOperator(node.operator);
+    }
+    if (node.kind === 'not') {
+        return savedViewFilterNodeUsesDynamicDate(node.child);
+    }
+    return node.children.some(savedViewFilterNodeUsesDynamicDate);
+}
+export function savedViewFilterUsesDynamicDate(filter) {
+    return savedViewFilterNodeUsesDynamicDate(filter.root);
+}
+export function savedViewFilterNodeUsesSelf(node) {
+    if (!node)
+        return false;
+    if (node.kind === 'condition')
+        return isSavedViewSelfValueRef(node.valueRef);
+    if (node.kind === 'not')
+        return savedViewFilterNodeUsesSelf(node.child);
+    return node.children.some(savedViewFilterNodeUsesSelf);
+}
+export function savedViewFilterUsesSelf(filter) {
+    return Boolean(filter && savedViewFilterNodeUsesSelf(filter.root));
+}
+export function createSavedViewFilter(root) {
+    if (savedViewFilterNodeUsesSelf(root))
+        return { version: 3, root };
+    return {
+        version: savedViewFilterNodeUsesDynamicDate(root) ? 2 : 1,
+        root,
+    };
+}
+export function resolveStandaloneSavedViewFilter(config, filter) {
+    const rule = config.noteDetail;
+    if (!rule || !savedViewFilterUsesSelf(filter))
+        return filter;
+    return {
+        version: 3,
+        root: {
+            kind: 'condition',
+            field: rule.field,
+            operator: 'equals',
+            value: rule.value,
+        },
+    };
+}
+const SAVED_VIEW_SELF_HOST_FIELDS = {
+    title: (host) => host.title,
+    source: (host) => host.source,
+    type: (host) => host.type,
+    created_at: (host) => host.createdAt,
+    updated_at: (host) => host.updatedAt,
+    starred_at: (host) => host.starredAt,
+    tags: (host) => host.tags,
+    zettel_boxes: (host) => host.zettelBoxes,
+};
+function asScalarSavedViewFilterValue(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    return undefined;
+}
+function asSavedViewFilterValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length !== 1)
+            return undefined;
+        return asScalarSavedViewFilterValue(value[0]);
+    }
+    return asScalarSavedViewFilterValue(value);
+}
+export function createSavedViewSelfBindContext(host) {
+    return {
+        resolve(field) {
+            if (!canSavedViewSelfSourceField(field))
+                return undefined;
+            if (field === SAVED_VIEW_SELF_ID_FIELD)
+                return asScalarSavedViewFilterValue(host.id);
+            if (field.startsWith('sys.')) {
+                const raw = SAVED_VIEW_SELF_HOST_FIELDS[field.slice('sys.'.length)]?.(host);
+                return asSavedViewFilterValue(raw);
+            }
+            const key = field.slice('prop.'.length);
+            return asSavedViewFilterValue(host.properties?.[key]);
+        },
+    };
+}
+function bindSavedViewCondition(condition, context) {
+    if (!isSavedViewSelfValueRef(condition.valueRef))
+        return condition;
+    const resolved = context?.resolve(condition.valueRef.field);
+    if (resolved === undefined)
+        return condition;
+    return {
+        kind: 'condition',
+        field: condition.field,
+        operator: condition.operator,
+        value: resolved,
+    };
+}
+function bindSavedViewNode(node, context) {
+    if (node.kind === 'condition')
+        return bindSavedViewCondition(node, context);
+    if (node.kind === 'not') {
+        const child = bindSavedViewNode(node.child, context);
+        return child === node.child ? node : { kind: 'not', child };
+    }
+    const children = node.children.map((child) => bindSavedViewNode(child, context));
+    const unchanged = children.every((child, index) => child === node.children[index]);
+    return unchanged ? node : { kind: 'group', operator: node.operator, children };
+}
+/** Replace resolved `$self` refs with literals. Unresolved refs stay and fail closed in SQL. */
+export function bindSavedViewFilter(filter, context) {
+    if (!filter)
+        return null;
+    if (!filter.root)
+        return filter;
+    const root = bindSavedViewNode(filter.root, context ?? null);
+    return root === filter.root ? filter : { ...filter, root };
+}
+/**
+ * A detail section appears only when `noteDetail` matches this note.
+ * The returned filter is the view filter with `$self` bound to the note.
+ */
+export function bindDetailSavedView(view, host) {
+    const rule = view.config.noteDetail;
+    if (!rule || !savedViewFilterUsesSelf(view.filter))
+        return null;
+    const context = createSavedViewSelfBindContext(host);
+    if (context.resolve(rule.field) !== rule.value)
+        return null;
+    return bindSavedViewFilter(view.filter, context);
+}
+export const savedViewFilterSchema = z
+    .object({
+    version: z.union([z.literal(1), z.literal(2), z.literal(3)]),
+    root: savedViewFilterNodeSchema.nullable(),
+})
+    .superRefine((filter, context) => {
+    const usesSelf = savedViewFilterNodeUsesSelf(filter.root);
+    const usesDynamicDate = savedViewFilterNodeUsesDynamicDate(filter.root);
+    if (filter.version === 1 && (usesDynamicDate || usesSelf)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['version'],
+            message: usesSelf
+                ? 'Self filter values require saved view filter version 3'
+                : 'Dynamic date filters require saved view filter version 2',
+        });
+    }
+    if (filter.version === 2 && usesSelf) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['version'],
+            message: 'Self filter values require saved view filter version 3',
+        });
+    }
+    if (!filter.root)
+        return;
+    const state = { count: 0, maxDepth: 0 };
+    inspectSavedViewFilterNode(filter.root, 1, state);
+    if (state.count > MAX_SAVED_VIEW_FILTER_NODES) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['root'],
+            message: `Saved view filters support at most ${MAX_SAVED_VIEW_FILTER_NODES} nodes`,
+        });
+    }
+    if (state.maxDepth > MAX_SAVED_VIEW_FILTER_DEPTH) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['root'],
+            message: `Saved view filters support at most ${MAX_SAVED_VIEW_FILTER_DEPTH} levels`,
+        });
+    }
+});
+export const SAVED_VIEW_LAYOUTS = ['table', 'list', 'card'];
+/**
+ * Analytics layer on `config_json` (shared contract with dinox-app).
+ * Both clients author and render these keys; every config write must round-trip them.
+ */
+export const SAVED_VIEW_CHART_TYPES = [
+    'bar',
+    'line',
+    'pie',
+    'area',
+    'contribute',
+    'waterfall',
+    'ring',
+    'funnel',
+    'scatter',
+    'treemap',
+];
+export const SAVED_VIEW_CHART_AGGREGATIONS = ['count', 'sum', 'avg'];
+export const SAVED_VIEW_CHART_TIME_BUCKETS = ['hour', 'day', 'week', 'month'];
+export const SAVED_VIEW_CHART_EXPR_OPS = ['*', '/', '+', '-'];
+export const MAX_SAVED_VIEW_CHARTS = 5;
+export const MAX_SAVED_VIEW_STATS = 6;
+export const MAX_SAVED_VIEW_CHART_TITLE_LENGTH = 80;
+export const MAX_SAVED_VIEW_STAT_TITLE_LENGTH = 80;
+export const MAX_SAVED_VIEW_STAT_UNIT_LENGTH = 16;
+export const MAX_SAVED_VIEW_CHART_LIMIT = 500;
+export const MAX_SAVED_VIEW_COMPUTED_COLUMNS = 10;
+export const MAX_SAVED_VIEW_SUMMARY_ITEMS = 20;
+export const MAX_SAVED_VIEW_COMPUTED_COLUMN_TITLE_LENGTH = 80;
+export const savedViewColumnSchema = z.object({
+    field: savedViewFieldRefSchema,
+});
+export const savedViewSortSchema = z.object({
+    field: savedViewFieldRefSchema,
+    direction: z.enum(['asc', 'desc']),
+});
+const SYS_DATE_FIELD_REFS = new Set([
+    'sys.created_at',
+    'sys.updated_at',
+    'sys.starred_at',
+]);
+const SYS_MULTI_VALUE_FIELD_REFS = new Set([
+    'sys.tags',
+    'sys.zettel_boxes',
+]);
+export function isSavedViewDateField(field, type) {
+    if (field.startsWith('sys.'))
+        return SYS_DATE_FIELD_REFS.has(field);
+    return type === 'date';
+}
+export function isSavedViewMultiValueField(field, type) {
+    if (field.startsWith('sys.'))
+        return SYS_MULTI_VALUE_FIELD_REFS.has(field);
+    return type === 'multi_select' || type === 'relation';
+}
+export function canGroupSavedViewChartByField(field, type) {
+    if (field === 'sys.primary_resource_type' ||
+        field === 'sys.title' ||
+        field === 'sys.images' ||
+        isSavedViewDisplayOnlyField(field)) {
+        return false;
+    }
+    if (field.startsWith('sys.'))
+        return true;
+    return (type !== undefined &&
+        type !== 'files' &&
+        type !== 'relation' &&
+        type !== 'place' &&
+        type !== 'unique_id');
+}
+export function getSavedViewChartTimeBucketsForField(field, type) {
+    return isSavedViewDateField(field, type) ? [...SAVED_VIEW_CHART_TIME_BUCKETS] : [];
+}
+export function canUseSavedViewChartMeasureField(field, type) {
+    return field.startsWith('prop.') && type === 'number';
+}
+export function getSavedViewChartAggregationsForDimension(dimensionField, dimensionType) {
+    if (isSavedViewMultiValueField(dimensionField, dimensionType))
+        return ['count'];
+    return [...SAVED_VIEW_CHART_AGGREGATIONS];
+}
+const savedViewChartDimensionSchema = z
+    .object({
+    field: savedViewFieldRefSchema,
+    timeBucket: z.enum(SAVED_VIEW_CHART_TIME_BUCKETS).optional(),
+})
+    .superRefine((dimension, context) => {
+    if (dimension.field === 'sys.primary_resource_type' ||
+        dimension.field === 'sys.title' ||
+        dimension.field === 'sys.images' ||
+        isSavedViewDisplayOnlyField(dimension.field)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['field'],
+            message: `${dimension.field} cannot be used as a chart dimension`,
+        });
+    }
+    if (dimension.field.startsWith('sys.')) {
+        const isDate = SYS_DATE_FIELD_REFS.has(dimension.field);
+        if (isDate && !dimension.timeBucket) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['timeBucket'],
+                message: 'Date chart dimensions require a timeBucket',
+            });
+        }
+        if (!isDate && dimension.timeBucket) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['timeBucket'],
+                message: 'timeBucket is only allowed on date chart dimensions',
+            });
+        }
+    }
+});
+const savedViewChartBinaryExprSchema = z
+    .object({
+    op: z.enum(SAVED_VIEW_CHART_EXPR_OPS),
+    left: savedViewFieldRefSchema,
+    right: savedViewFieldRefSchema,
+})
+    .superRefine((expr, context) => {
+    if (!expr.left.startsWith('prop.')) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['left'],
+            message: 'Chart expressions only support number property fields on the left',
+        });
+    }
+    if (!expr.right.startsWith('prop.')) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['right'],
+            message: 'Chart expressions only support number property fields on the right',
+        });
+    }
+});
+const savedViewChartMeasureSchema = z
+    .object({
+    field: savedViewFieldRefSchema.nullable(),
+    aggregation: z.enum(SAVED_VIEW_CHART_AGGREGATIONS),
+    expr: savedViewChartBinaryExprSchema.optional(),
+})
+    .superRefine((measure, context) => {
+    if (measure.aggregation === 'count') {
+        if (measure.field !== null) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['field'],
+                message: 'count does not accept a measure field',
+            });
+        }
+        if (measure.expr) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['expr'],
+                message: 'count does not accept a measure expression',
+            });
+        }
+        return;
+    }
+    const hasField = measure.field !== null;
+    const hasExpr = measure.expr !== undefined;
+    if (hasField === hasExpr) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: hasExpr ? ['field'] : ['expr'],
+            message: `${measure.aggregation} requires either a measure field or an expression, not both`,
+        });
+    }
+    if (hasField && measure.field && !measure.field.startsWith('prop.')) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['field'],
+            message: `${measure.aggregation} only supports number property fields`,
+        });
+    }
+});
+export const savedViewChartSchema = z
+    .object({
+    id: z.string().trim().min(1).max(64),
+    title: z.string().max(MAX_SAVED_VIEW_CHART_TITLE_LENGTH).optional(),
+    type: z.enum(SAVED_VIEW_CHART_TYPES),
+    dimensions: z.tuple([savedViewChartDimensionSchema]),
+    measures: z.tuple([savedViewChartMeasureSchema]),
+    orderBy: z
+        .object({
+        by: z.enum(['bucket', 'value']),
+        direction: z.enum(['asc', 'desc']),
+    })
+        .optional(),
+    limit: z.number().int().min(1).max(MAX_SAVED_VIEW_CHART_LIMIT).optional(),
+})
+    .superRefine((chart, context) => {
+    if (chart.type === 'contribute' && chart.dimensions[0]?.timeBucket !== 'day') {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['dimensions', 0, 'timeBucket'],
+            message: 'contribute charts require a day timeBucket dimension',
+        });
+    }
+});
+export const savedViewStatSchema = z.object({
+    id: z.string().trim().min(1).max(64),
+    title: z.string().max(MAX_SAVED_VIEW_STAT_TITLE_LENGTH).optional(),
+    unit: z.string().trim().max(MAX_SAVED_VIEW_STAT_UNIT_LENGTH).optional(),
+    measure: savedViewChartMeasureSchema,
+});
+const CALC_COLUMN_KEY_PATTERN = /^calc\.[0-9A-Za-z_-]{1,64}$/;
+export function isSavedViewTableColumnKey(value) {
+    if (isSavedViewFieldRef(value))
+        return true;
+    return typeof value === 'string' && CALC_COLUMN_KEY_PATTERN.test(value);
+}
+const savedViewTableColumnKeySchema = z.custom(isSavedViewTableColumnKey, 'Invalid saved view table column key');
+export const savedViewComputedColumnSchema = z.object({
+    id: z.string().trim().min(1).max(64),
+    title: z.string().max(MAX_SAVED_VIEW_COMPUTED_COLUMN_TITLE_LENGTH).optional(),
+    expr: savedViewChartBinaryExprSchema,
+});
+export const savedViewSummaryItemSchema = z.object({
+    column: savedViewTableColumnKeySchema,
+    aggregation: z.enum(SAVED_VIEW_CHART_AGGREGATIONS),
+});
+export const savedViewConfigSchema = z
+    .object({
+    version: z.literal(1),
+    noteDetail: z
+        .object({
+        field: savedViewFieldRefSchema,
+        value: z.union([z.string().min(1), z.number().finite(), z.boolean()]),
+    })
+        .optional(),
+    layout: z.enum(SAVED_VIEW_LAYOUTS),
+    columns: z.array(savedViewColumnSchema).min(1).max(100),
+    sort: z.array(savedViewSortSchema).max(20).optional(),
+    stats: z.array(savedViewStatSchema).max(MAX_SAVED_VIEW_STATS).optional(),
+    charts: z.array(savedViewChartSchema).max(MAX_SAVED_VIEW_CHARTS).optional(),
+    computedColumns: z
+        .array(savedViewComputedColumnSchema)
+        .max(MAX_SAVED_VIEW_COMPUTED_COLUMNS)
+        .optional(),
+    summary: z.array(savedViewSummaryItemSchema).max(MAX_SAVED_VIEW_SUMMARY_ITEMS).optional(),
+})
+    .superRefine((config, context) => {
+    if (config.columns[0]?.field !== 'sys.title') {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['columns', 0, 'field'],
+            message: 'The title field must be the first saved view column',
+        });
+    }
+    const columnFields = new Set();
+    config.columns.forEach((column, index) => {
+        if (columnFields.has(column.field)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['columns', index, 'field'],
+                message: 'Saved view columns must be unique',
+            });
+        }
+        columnFields.add(column.field);
+    });
+    const sortFields = new Set();
+    config.sort?.forEach((sort, index) => {
+        if (sortFields.has(sort.field)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['sort', index, 'field'],
+                message: 'Saved view sort fields must be unique',
+            });
+        }
+        sortFields.add(sort.field);
+    });
+    const statIds = new Set();
+    config.stats?.forEach((stat, index) => {
+        if (statIds.has(stat.id)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['stats', index, 'id'],
+                message: 'Saved view stat ids must be unique',
+            });
+        }
+        statIds.add(stat.id);
+    });
+    const chartIds = new Set();
+    config.charts?.forEach((chart, index) => {
+        if (chartIds.has(chart.id)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['charts', index, 'id'],
+                message: 'Saved view chart ids must be unique',
+            });
+        }
+        chartIds.add(chart.id);
+    });
+    const computedColumnIds = new Set();
+    config.computedColumns?.forEach((column, index) => {
+        if (computedColumnIds.has(column.id)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['computedColumns', index, 'id'],
+                message: 'Saved view computed column ids must be unique',
+            });
+        }
+        computedColumnIds.add(column.id);
+    });
+    const summaryColumns = new Set();
+    config.summary?.forEach((item, index) => {
+        if (summaryColumns.has(item.column)) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['summary', index, 'column'],
+                message: 'Saved view summary columns must be unique',
+            });
+        }
+        summaryColumns.add(item.column);
+    });
+});
+export function createDefaultSavedViewFilter() {
+    return createSavedViewFilter(null);
+}
+export function createDefaultSavedViewConfig() {
+    return {
+        version: 1,
+        layout: 'table',
+        columns: [{ field: 'sys.title' }, { field: 'sys.updated_at' }],
+        sort: [{ field: 'sys.updated_at', direction: 'desc' }],
+    };
+}
+export const aiGenerateSavedViewPlanRequestSchema = z.object({
+    prompt: z.string().trim().min(1).max(4000),
+    modelSelector: z.string().trim().min(1).max(512).optional(),
+    locale: z.string().trim().min(1).max(35).optional(),
+    timeZone: z.string().trim().min(1).max(100).optional(),
+}).strict();
+const savedViewZettelBoxDetailsSchema = z
+    .array(z.object({
+    fullPath: z.string().trim().min(1).max(1_000),
+    color: z.string().trim().max(200).nullable(),
+}))
+    .max(100);
+export function parseSavedViewZettelBoxDetails(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = savedViewZettelBoxDetailsSchema.safeParse(JSON.parse(value));
+        return parsed.success ? parsed.data : [];
+    }
+    catch {
+        return [];
+    }
+}
+const nullableShortStringSchema = z.string().trim().max(120).nullable();
+const nullableIdSchema = z.string().trim().min(1).max(200).nullable();
+const nullableTimestampSchema = z.string().trim().min(1).max(64).nullable();
+export const savedViewCatalogInputSchema = z.object({
+    userId: z.string().trim().min(1),
+    limit: z.number().int().positive().max(5000).optional(),
+});
+export const savedViewCreateInputSchema = z.object({
+    userId: z.string().trim().min(1),
+    name: z.string().trim().min(1).max(120),
+    emoji: nullableShortStringSchema.optional(),
+    filter: savedViewFilterSchema,
+    config: savedViewConfigSchema,
+    templateId: nullableIdSchema.optional(),
+    groupId: nullableIdSchema.optional(),
+    sortRank: z.number().int().nullable().optional(),
+    pinnedAt: nullableTimestampSchema.optional(),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+export const savedViewUpdateInputSchema = z
+    .object({
+    id: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    name: z.string().trim().min(1).max(120).optional(),
+    emoji: nullableShortStringSchema.optional(),
+    filter: savedViewFilterSchema.optional(),
+    config: savedViewConfigSchema.optional(),
+    templateId: nullableIdSchema.optional(),
+    groupId: nullableIdSchema.optional(),
+    sortRank: z.number().int().nullable().optional(),
+    pinnedAt: nullableTimestampSchema.optional(),
+    updatedAt: z.string().trim().min(1).max(64),
+})
+    .refine((input) => input.name !== undefined ||
+    input.emoji !== undefined ||
+    input.filter !== undefined ||
+    input.config !== undefined ||
+    input.templateId !== undefined ||
+    input.groupId !== undefined ||
+    input.sortRank !== undefined ||
+    input.pinnedAt !== undefined, { message: 'At least one saved-view field must be updated' });
+export const savedViewSoftDeleteInputSchema = z.object({
+    id: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    updatedAt: z.string().trim().min(1).max(64),
+});
+export const savedViewPageInputSchema = z.object({
+    viewId: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    timeZone: z.string().trim().min(1).max(100).optional(),
+    limit: z.number().int().positive().max(500).optional(),
+    offset: z.number().int().nonnegative().optional(),
+});
+export const savedViewCountInputSchema = z.object({
+    viewId: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    timeZone: z.string().trim().min(1).max(100).optional(),
+});
+export const savedViewAnalyticsInputSchema = z.object({
+    viewId: z.string().trim().min(1),
+    userId: z.string().trim().min(1),
+    timeZone: z.string().trim().min(1).max(100).optional(),
+    draft: z
+        .object({
+        stats: z.array(savedViewStatSchema).max(MAX_SAVED_VIEW_STATS).optional(),
+        charts: z.array(savedViewChartSchema).max(MAX_SAVED_VIEW_CHARTS).optional(),
+        computedColumns: z
+            .array(savedViewComputedColumnSchema)
+            .max(MAX_SAVED_VIEW_COMPUTED_COLUMNS)
+            .optional(),
+        summary: z.array(savedViewSummaryItemSchema).max(MAX_SAVED_VIEW_SUMMARY_ITEMS).optional(),
+    })
+        .optional(),
+});
+export const savedViewNoteDetailInputSchema = z.object({
+    userId: z.string().trim().min(1),
+    noteId: z.string().trim().min(1),
+    timeZone: z.string().trim().min(1).max(100).optional(),
+    limit: z.number().int().positive().max(100).optional(),
+});