adminizer 5.0.0-build.2 → 5.0.0-build.21

package/lib/docs/DocumentationHandler.d.ts

@@ -0,0 +1,100 @@
+import type { User } from '../../models/User.js';
+import type { Adminizer } from '../Adminizer.js';
+import type { AbstractDocumentation, DocContent, DocMeta, DocSearchQuery, DocSearchResult } from './AbstractDocumentation.js';
+export declare const DOCUMENTATION_BASE_TOKEN = "read-documentation";
+export declare const DOCUMENTATION_DEPARTMENT = "documentation";
+/** Contextual table of contents handed to the UI as a shared Inertia prop. */
+export interface DocContextSummary {
+    count: number;
+    items: Array<{
+        id: string;
+        title: string;
+        section?: string;
+    }>;
+}
+/**
+ * The adminizer-side facade of the documentation subsystem: holds the single
+ * active `AbstractDocumentation` implementation and applies access rights to
+ * every result before it can reach the UI, the HTTP API or the assistant.
+ *
+ * Implementations know nothing about users; a document a user may not read
+ * simply does not exist for them — it is absent from listings, search results,
+ * the keyword map and link resolution.
+ *
+ * Per-document rights are declarative: the document author references an
+ * existing access token in the metadata (a model token like `read-Test-model`
+ * via `models`, or any custom token via `accessRightsToken`). The subsystem
+ * never creates tokens from documents — a referenced token that nobody
+ * registered simply keeps the document admin-only.
+ */
+export declare class DocumentationHandler {
+    private readonly adminizer;
+    private readonly bind?;
+    private service?;
+    private owner?;
+    private bound;
+    /**
+     * `bind` is the wiring Adminizer installs (token, navigation, skills, HTTP
+     * routes); it runs at most once, the moment the feature has both of its
+     * switches: `config.documentation.enabled` and a registered implementation.
+     */
+    constructor(adminizer: Adminizer, bind?: () => void);
+    /** Base access token; without it the whole subsystem is invisible. */
+    get baseToken(): string;
+    get enabled(): boolean;
+    isRegistered(): boolean;
+    /**
+     * Activates the singleton implementation. Registering a second one is an
+     * error: replacing the active service must be an explicit `unregister`
+     * followed by a new `register`.
+     *
+     * With `config.documentation.enabled` set, the first registration also
+     * brings the subsystem up — token, navigation, skills and HTTP routes.
+     * None of it exists before that, so a missing implementation is
+     * indistinguishable from a disabled feature.
+     */
+    register(service: AbstractDocumentation, owner?: string): void;
+    /**
+     * Runs the installed wiring once both switches of the feature hold. Called
+     * from `register()` and again from `Adminizer.init` — that second call
+     * covers a service registered before the config was read. Re-registering
+     * after an `unregister` reuses the wiring instead of mounting it twice.
+     */
+    activate(): void;
+    unregister(owner?: string): boolean;
+    /** The locale documentation is served in when the consumer names none. */
+    localeFor(user?: User): string | undefined;
+    /** Metadata of every document this user may read. */
+    list(user: User, locale?: string): Promise<DocMeta[]>;
+    /** One document, or `undefined` when it does not exist for this user. */
+    get(user: User, id: string, locale?: string): Promise<DocContent | undefined>;
+    search(user: User, query: DocSearchQuery, locale?: string): Promise<DocSearchResult[]>;
+    /** Whether the subsystem is up and this user may read documentation at all. */
+    canRead(user?: User): Promise<boolean>;
+    /**
+     * The contextual table of contents of an admin page: metadata only, and
+     * `null` when the subsystem is off or the user may not read documentation.
+     * Shared with every page as a prop, so it never throws.
+     */
+    forContextMeta(user: User, url: string, locale?: string): Promise<DocContextSummary | null>;
+    /** Documents bound to a place in the admin panel this user may read. */
+    forContext(user: User, ctx: {
+        url?: string;
+        model?: string;
+    }, locale?: string): Promise<DocMeta[]>;
+    /**
+     * Keyword → document ids over accessible documents only: keywords of a
+     * hidden document never reach the map, empty keywords are dropped.
+     */
+    keywords(user: User, locale?: string): Promise<Map<string, string[]>>;
+    /** Resolves an in-document reference; a target this user may not read stays unresolved. */
+    resolveLink(user: User, fromId: string, ref: string): Promise<string | undefined>;
+    private requireService;
+    private permitted;
+    /**
+     * The access decision of the subsystem: the base token, then the per-doc
+     * token, then — for model-bound documents — read access to at least one of
+     * the models, with the same token DataAccessor gates the data itself.
+     */
+    private allowed;
+}

package/lib/docs/DocumentationHandler.js

@@ -0,0 +1,198 @@
+export const DOCUMENTATION_BASE_TOKEN = 'read-documentation';
+export const DOCUMENTATION_DEPARTMENT = 'documentation';
+/**
+ * The adminizer-side facade of the documentation subsystem: holds the single
+ * active `AbstractDocumentation` implementation and applies access rights to
+ * every result before it can reach the UI, the HTTP API or the assistant.
+ *
+ * Implementations know nothing about users; a document a user may not read
+ * simply does not exist for them — it is absent from listings, search results,
+ * the keyword map and link resolution.
+ *
+ * Per-document rights are declarative: the document author references an
+ * existing access token in the metadata (a model token like `read-Test-model`
+ * via `models`, or any custom token via `accessRightsToken`). The subsystem
+ * never creates tokens from documents — a referenced token that nobody
+ * registered simply keeps the document admin-only.
+ */
+export class DocumentationHandler {
+    adminizer;
+    bind;
+    service;
+    owner;
+    bound = false;
+    /**
+     * `bind` is the wiring Adminizer installs (token, navigation, skills, HTTP
+     * routes); it runs at most once, the moment the feature has both of its
+     * switches: `config.documentation.enabled` and a registered implementation.
+     */
+    constructor(adminizer, bind) {
+        this.adminizer = adminizer;
+        this.bind = bind;
+    }
+    /** Base access token; without it the whole subsystem is invisible. */
+    get baseToken() {
+        return DOCUMENTATION_BASE_TOKEN;
+    }
+    get enabled() {
+        return this.adminizer.config.documentation?.enabled === true && Boolean(this.service);
+    }
+    isRegistered() {
+        return Boolean(this.service);
+    }
+    /**
+     * Activates the singleton implementation. Registering a second one is an
+     * error: replacing the active service must be an explicit `unregister`
+     * followed by a new `register`.
+     *
+     * With `config.documentation.enabled` set, the first registration also
+     * brings the subsystem up — token, navigation, skills and HTTP routes.
+     * None of it exists before that, so a missing implementation is
+     * indistinguishable from a disabled feature.
+     */
+    register(service, owner = 'host') {
+        if (this.service) {
+            throw new Error(`Documentation service is already registered by "${this.owner}"`);
+        }
+        service.adminizer = this.adminizer;
+        this.service = service;
+        this.owner = owner;
+        this.activate();
+    }
+    /**
+     * Runs the installed wiring once both switches of the feature hold. Called
+     * from `register()` and again from `Adminizer.init` — that second call
+     * covers a service registered before the config was read. Re-registering
+     * after an `unregister` reuses the wiring instead of mounting it twice.
+     */
+    activate() {
+        if (this.bound || !this.bind || !this.service)
+            return;
+        if (this.adminizer.config?.documentation?.enabled !== true)
+            return;
+        this.bound = true;
+        this.bind();
+    }
+    unregister(owner) {
+        if (!this.service || (owner && this.owner !== owner))
+            return false;
+        this.service = undefined;
+        this.owner = undefined;
+        return true;
+    }
+    /** The locale documentation is served in when the consumer names none. */
+    localeFor(user) {
+        if (user?.locale)
+            return user.locale;
+        const translation = this.adminizer.config.translation;
+        return typeof translation === 'object' && translation ? translation.defaultLocale : undefined;
+    }
+    /** Metadata of every document this user may read. */
+    async list(user, locale) {
+        const service = this.requireService();
+        return this.permitted(user, await service.list(locale));
+    }
+    /** One document, or `undefined` when it does not exist for this user. */
+    async get(user, id, locale) {
+        const service = this.requireService();
+        const content = await service.get(id, locale);
+        if (!content || !(await this.allowed(user, content.meta)))
+            return undefined;
+        return content;
+    }
+    async search(user, query, locale) {
+        const service = this.requireService();
+        const results = await service.search(query, locale);
+        const filtered = [];
+        for (const result of results) {
+            if (await this.allowed(user, result.meta))
+                filtered.push(result);
+        }
+        return filtered;
+    }
+    /** Whether the subsystem is up and this user may read documentation at all. */
+    async canRead(user) {
+        if (!this.enabled || !user)
+            return false;
+        return Boolean(await this.adminizer.accessRightsHelper.hasPermission(this.baseToken, user));
+    }
+    /**
+     * The contextual table of contents of an admin page: metadata only, and
+     * `null` when the subsystem is off or the user may not read documentation.
+     * Shared with every page as a prop, so it never throws.
+     */
+    async forContextMeta(user, url, locale) {
+        if (!(await this.canRead(user)))
+            return null;
+        const documents = await this.forContext(user, { url }, locale ?? this.localeFor(user));
+        return {
+            count: documents.length,
+            items: documents.map((meta) => ({ id: meta.id, title: meta.title, section: meta.section })),
+        };
+    }
+    /** Documents bound to a place in the admin panel this user may read. */
+    async forContext(user, ctx, locale) {
+        const service = this.requireService();
+        return this.permitted(user, await service.forContext(ctx, locale));
+    }
+    /**
+     * Keyword → document ids over accessible documents only: keywords of a
+     * hidden document never reach the map, empty keywords are dropped.
+     */
+    async keywords(user, locale) {
+        const service = this.requireService();
+        const visible = new Set((await this.list(user, locale)).map((meta) => meta.id));
+        const map = new Map();
+        for (const [keyword, ids] of await service.keywords(locale)) {
+            const permitted = ids.filter((id) => visible.has(id));
+            if (permitted.length > 0)
+                map.set(keyword, permitted);
+        }
+        return map;
+    }
+    /** Resolves an in-document reference; a target this user may not read stays unresolved. */
+    async resolveLink(user, fromId, ref) {
+        const service = this.requireService();
+        const target = await service.resolveLink(fromId, ref);
+        if (!target)
+            return undefined;
+        const metas = await service.list();
+        const meta = metas.find((candidate) => candidate.id === target);
+        if (!meta || !(await this.allowed(user, meta)))
+            return undefined;
+        return target;
+    }
+    requireService() {
+        if (!this.service)
+            throw new Error('No documentation service is registered');
+        return this.service;
+    }
+    async permitted(user, metas) {
+        const filtered = [];
+        for (const meta of metas) {
+            if (await this.allowed(user, meta))
+                filtered.push(meta);
+        }
+        return filtered;
+    }
+    /**
+     * The access decision of the subsystem: the base token, then the per-doc
+     * token, then — for model-bound documents — read access to at least one of
+     * the models, with the same token DataAccessor gates the data itself.
+     */
+    async allowed(user, meta) {
+        const has = (token) => this.adminizer.accessRightsHelper.hasPermission(token, user);
+        if (!(await has(this.baseToken)))
+            return false;
+        if (meta.accessRightsToken && !(await has(meta.accessRightsToken)))
+            return false;
+        if (meta.models.length > 0) {
+            for (const model of meta.models) {
+                if (await has(`read-${model}-model`))
+                    return true;
+            }
+            return false;
+        }
+        return true;
+    }
+}

package/lib/docs/FileDocumentation.d.ts

@@ -0,0 +1,47 @@
+import { AbstractDocumentation, DocContent, DocMeta } from './AbstractDocumentation.js';
+export interface FileDocumentationOptions {
+    /** Directory scanned (recursively) for markdown documents. */
+    dir: string;
+    /** Locale of files without a locale suffix. @default "en" */
+    defaultLocale?: string;
+    /** Watch the directory and drop the cache on changes. @default false */
+    watch?: boolean;
+}
+/**
+ * The reference implementation bundled with adminizer: documents are markdown
+ * files with a frontmatter header, translations are sibling files with a
+ * locale suffix (`intro.md` + `intro.ru.md` → document `intro` in two
+ * locales). Structural metadata (bindings, rights, section) is taken from the
+ * default-locale file; title and keywords are translatable per file.
+ *
+ * Frontmatter is an intentionally small `key: value` subset (quoted strings,
+ * `[a, b]` inline lists, `- item` dash lists), not full YAML.
+ */
+export declare class FileDocumentation extends AbstractDocumentation {
+    private readonly dir;
+    private readonly defaultLocale;
+    private cache?;
+    private readonly changeCallbacks;
+    private watcher?;
+    private watchDebounce?;
+    constructor(options: FileDocumentationOptions);
+    list(locale?: string): Promise<DocMeta[]>;
+    get(id: string, locale?: string): Promise<DocContent | undefined>;
+    onChange(cb: (ids?: string[]) => void): void;
+    /** Drops the cache; the next call rescans the directory. */
+    reload(): void;
+    stopWatcher(): void;
+    private startWatcher;
+    private scan;
+    private scanDirectory;
+    /** `<id>.md` is the default locale, `<id>.<locale>.md` a translation. */
+    private parseFile;
+    private buildMeta;
+    /** Exact locale, else the default locale, else whatever exists. */
+    private pickTranslation;
+    private splitFrontmatter;
+    private parseFrontmatter;
+    private stringList;
+    private unquote;
+    private extractTitle;
+}

package/lib/docs/FileDocumentation.js

@@ -0,0 +1,189 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { AbstractDocumentation } from './AbstractDocumentation.js';
+/**
+ * The reference implementation bundled with adminizer: documents are markdown
+ * files with a frontmatter header, translations are sibling files with a
+ * locale suffix (`intro.md` + `intro.ru.md` → document `intro` in two
+ * locales). Structural metadata (bindings, rights, section) is taken from the
+ * default-locale file; title and keywords are translatable per file.
+ *
+ * Frontmatter is an intentionally small `key: value` subset (quoted strings,
+ * `[a, b]` inline lists, `- item` dash lists), not full YAML.
+ */
+export class FileDocumentation extends AbstractDocumentation {
+    dir;
+    defaultLocale;
+    cache;
+    changeCallbacks = [];
+    watcher;
+    watchDebounce;
+    constructor(options) {
+        super();
+        this.dir = path.resolve(options.dir);
+        this.defaultLocale = options.defaultLocale ?? 'en';
+        if (options.watch)
+            this.startWatcher();
+    }
+    async list(locale) {
+        const documents = await this.scan();
+        return [...documents.entries()].map(([id, translations]) => this.buildMeta(id, translations, locale));
+    }
+    async get(id, locale) {
+        const documents = await this.scan();
+        const translations = documents.get(id);
+        if (!translations)
+            return undefined;
+        const [servedLocale, file] = this.pickTranslation(translations, locale);
+        return {
+            meta: this.buildMeta(id, translations, locale),
+            markdown: file.markdown,
+            locale: servedLocale,
+        };
+    }
+    onChange(cb) {
+        this.changeCallbacks.push(cb);
+    }
+    /** Drops the cache; the next call rescans the directory. */
+    reload() {
+        this.cache = undefined;
+        for (const cb of this.changeCallbacks)
+            cb();
+    }
+    stopWatcher() {
+        this.watcher?.close();
+        this.watcher = undefined;
+        if (this.watchDebounce)
+            clearTimeout(this.watchDebounce);
+    }
+    startWatcher() {
+        try {
+            this.watcher = fs.watch(this.dir, { recursive: true }, () => {
+                if (this.watchDebounce)
+                    clearTimeout(this.watchDebounce);
+                this.watchDebounce = setTimeout(() => this.reload(), 200);
+            });
+        }
+        catch {
+            // A missing directory or an unsupported platform degrades to a static implementation.
+        }
+    }
+    scan() {
+        this.cache ??= this.scanDirectory();
+        return this.cache;
+    }
+    async scanDirectory() {
+        const documents = new Map();
+        let files;
+        try {
+            files = (await fs.promises.readdir(this.dir, { recursive: true, withFileTypes: true }))
+                .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+                .map((entry) => path.join(entry.parentPath ?? entry.path, entry.name));
+        }
+        catch {
+            return documents;
+        }
+        for (const file of files) {
+            const parsed = this.parseFile(await fs.promises.readFile(file, 'utf8'), path.basename(file));
+            if (!parsed)
+                continue;
+            const { id, doc } = parsed;
+            const translations = documents.get(id) ?? new Map();
+            translations.set(doc.locale, doc);
+            documents.set(id, translations);
+        }
+        return documents;
+    }
+    /** `<id>.md` is the default locale, `<id>.<locale>.md` a translation. */
+    parseFile(raw, filename) {
+        const base = filename.replace(/\.md$/, '');
+        const localeMatch = base.match(/^(.+)\.([a-z]{2}(?:-[A-Za-z]{2})?)$/);
+        const fromName = localeMatch ? { id: localeMatch[1], locale: localeMatch[2] } : { id: base, locale: this.defaultLocale };
+        const { front, body } = this.splitFrontmatter(raw);
+        const id = front.id || fromName.id;
+        if (!id)
+            return undefined;
+        return {
+            id,
+            doc: {
+                locale: front.locale || fromName.locale,
+                title: front.title || this.extractTitle(body) || id,
+                keywords: this.stringList(front.keywords),
+                section: front.section || undefined,
+                models: this.stringList(front.models),
+                urls: this.stringList(front.urls),
+                accessRightsToken: front.accessRightsToken || undefined,
+                markdown: body.trim(),
+            },
+        };
+    }
+    buildMeta(id, translations, locale) {
+        const [, localized] = this.pickTranslation(translations, locale);
+        const structural = translations.get(this.defaultLocale) ?? localized;
+        return {
+            id,
+            title: localized.title,
+            section: structural.section,
+            keywords: localized.keywords,
+            models: structural.models,
+            urls: structural.urls,
+            accessRightsToken: structural.accessRightsToken,
+            locales: [...translations.keys()],
+        };
+    }
+    /** Exact locale, else the default locale, else whatever exists. */
+    pickTranslation(translations, locale) {
+        for (const wanted of [locale, this.defaultLocale]) {
+            const file = wanted ? translations.get(wanted) : undefined;
+            if (file)
+                return [wanted, file];
+        }
+        const [fallbackLocale, file] = [...translations.entries()][0];
+        return [fallbackLocale, file];
+    }
+    splitFrontmatter(raw) {
+        const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+        if (!match)
+            return { front: {}, body: raw };
+        return { front: this.parseFrontmatter(match[1]), body: raw.slice(match[0].length) };
+    }
+    parseFrontmatter(block) {
+        const front = {};
+        let listKey;
+        for (const line of block.split('\n')) {
+            const dashItem = line.match(/^\s+-\s+(.*)$/);
+            if (dashItem && listKey) {
+                front[listKey].push(this.unquote(dashItem[1]));
+                continue;
+            }
+            const pair = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+            if (!pair)
+                continue;
+            const [, key, value] = pair;
+            if (value === '') {
+                front[key] = [];
+                listKey = key;
+                continue;
+            }
+            listKey = undefined;
+            const inlineList = value.match(/^\[(.*)]$/);
+            front[key] = inlineList
+                ? inlineList[1].split(',').map((item) => this.unquote(item)).filter(Boolean)
+                : this.unquote(value);
+        }
+        return front;
+    }
+    stringList(value) {
+        if (Array.isArray(value))
+            return value.map(String).filter(Boolean);
+        if (typeof value === 'string' && value)
+            return [value];
+        return [];
+    }
+    unquote(value) {
+        return value.trim().replace(/^(["'])(.*)\1$/, '$2');
+    }
+    extractTitle(body) {
+        return body.match(/^#\s+(.+)$/m)?.[1].trim();
+    }
+}

package/lib/docs/docsAgentSkills.d.ts

@@ -0,0 +1,10 @@
+import type { Adminizer } from '../Adminizer.js';
+import type { AiAssistantAgentSkill } from '../ai-assistant/AiAssistantAgentSkillHandler.js';
+/**
+ * Documentation skills of the assistant. Every call goes through
+ * `DocumentationHandler`, so the agent reads documentation with exactly the
+ * permissions of the user it acts for; a document the user may not read does
+ * not exist for the agent either. Registered only when the documentation
+ * subsystem is enabled.
+ */
+export declare function buildDocumentationAgentSkills(adminizer: Adminizer): AiAssistantAgentSkill[];

package/lib/docs/docsAgentSkills.js

@@ -0,0 +1,93 @@
+function describeMeta(meta) {
+    return {
+        id: meta.id,
+        title: meta.title,
+        section: meta.section,
+        keywords: meta.keywords.length ? meta.keywords : undefined,
+        models: meta.models.length ? meta.models : undefined,
+    };
+}
+/**
+ * Documentation skills of the assistant. Every call goes through
+ * `DocumentationHandler`, so the agent reads documentation with exactly the
+ * permissions of the user it acts for; a document the user may not read does
+ * not exist for the agent either. Registered only when the documentation
+ * subsystem is enabled.
+ */
+export function buildDocumentationAgentSkills(adminizer) {
+    const handler = () => adminizer.documentationHandler;
+    const token = adminizer.documentationHandler.baseToken;
+    const listKeywords = {
+        id: 'list_documentation_keywords',
+        description: 'Map of documentation keywords to the ids of the admin-panel documentation the current user may read.'
+            + ' Use it to discover what topics are covered before searching.',
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        accessRightsToken: token,
+        execute: async (_input, { user }) => {
+            const keywords = await handler().keywords(user, handler().localeFor(user));
+            return { keywords: Object.fromEntries(keywords) };
+        },
+    };
+    const search = {
+        id: 'search_documentation',
+        description: 'Search the admin-panel documentation the current user may read: full-text query, keyword filters,'
+            + ' or scoping to an admin URL or a data model. Returns matching documents with snippets;'
+            + ' read a whole document with read_documentation.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Full-text query matched against titles, keywords and content.' },
+                keywords: {
+                    type: 'array', items: { type: 'string' },
+                    description: 'Keywords the documents must all have, as returned by list_documentation_keywords.',
+                },
+                url: { type: 'string', description: 'Admin path to scope to, e.g. the page the user is looking at.' },
+                model: { type: 'string', description: 'Data model name to scope to.' },
+            },
+            additionalProperties: false,
+        },
+        accessRightsToken: token,
+        execute: async (input, { user }) => {
+            const results = await handler().search(user, {
+                query: typeof input.query === 'string' ? input.query : undefined,
+                keywords: Array.isArray(input.keywords) ? input.keywords.map(String) : undefined,
+                url: typeof input.url === 'string' ? input.url : undefined,
+                model: typeof input.model === 'string' ? input.model : undefined,
+            }, handler().localeFor(user));
+            return {
+                results: results.map((result) => ({
+                    ...describeMeta(result.meta),
+                    snippets: result.snippets.length ? result.snippets : undefined,
+                })),
+            };
+        },
+    };
+    const read = {
+        id: 'read_documentation',
+        description: 'Read one admin-panel documentation document, in the locale of the current user,'
+            + ' by the id returned from search_documentation or list_documentation_keywords.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Document id.' },
+            },
+            required: ['id'],
+            additionalProperties: false,
+        },
+        accessRightsToken: token,
+        execute: async (input, { user }) => {
+            const id = String(input.id ?? '').trim();
+            if (!id)
+                throw new Error('id of the document to read is required');
+            const content = await handler().get(user, id, handler().localeFor(user));
+            if (!content)
+                throw new Error(`Document "${id}" is not available.`);
+            return {
+                ...describeMeta(content.meta),
+                locale: content.locale,
+                markdown: content.markdown,
+            };
+        },
+    };
+    return [listKeywords, search, read];
+}

package/lib/feedback/FeedbackHandler.d.ts

@@ -1,5 +1,5 @@
-import { Adminizer } from '../Adminizer';
-import { AbstractFeedbackHandler } from './AbstractFeedbackHandler';
+import { Adminizer } from '../Adminizer.js';
+import { AbstractFeedbackHandler } from './AbstractFeedbackHandler.js';
 export declare class FeedbackHandler {
     private handler;
     private adminizer;

package/lib/filters/ConditionValidator.d.ts

@@ -1,4 +1,4 @@
-import { FilterCondition, FilterOperator } from '../../models/Filter';
+import { FilterCondition, FilterOperator } from '../../models/Filter.js';
 /**
  * Security event types for logging suspicious filter attempts
  */

package/lib/filters/FilterCustomFieldHandler.d.ts

@@ -1,2 +1,2 @@
-export * from './CustomFilterHandler';
-export { default } from './CustomFilterHandler';
+export * from './CustomFilterHandler.js';
+export { default } from './CustomFilterHandler.js';

package/lib/filters/FilterService.d.ts

@@ -1,7 +1,7 @@
-import { Adminizer } from '../Adminizer';
-import { Filter } from '../../models/Filter';
-import { FilterColumn } from '../../models/FilterColumn';
-import { User } from '../../models/User';
+import { Adminizer } from '../Adminizer.js';
+import { Filter } from '../../models/Filter.js';
+import { FilterColumn } from '../../models/FilterColumn.js';
+import { User } from '../../models/User.js';
 /**
  * FilterService - manages filter operations
  *