@table-bro/mcp 0.0.0-stage → 1.2.0

package/dist/spec/schema.js

@@ -0,0 +1,278 @@
+import { cssVariables } from './css-variables.js';
+const string = { type: 'string' };
+const boolean = { type: 'boolean' };
+const button = {
+    type: 'object',
+    properties: {
+        title: string,
+        action: { type: 'string', description: 'The action of the bro-action event on a click, as export' },
+        icon: { type: 'string', description: 'The name of a Material icon, as download: in the mat skin a button of the toolbar is an icon with a tooltip, the other skins show the title' }
+    },
+    required: ['title', 'action'],
+    additionalProperties: false
+};
+/**
+ * The JSON Schema of BroTableSpec, for the tools of the MCP server and the reference. It gives the form; validateSpec
+ * checks the meaning: the names of the fields, the cells and the filters, the values of the CSS variables.
+ */
+export const specSchema = {
+    '$schema': 'https://json-schema.org/draft/2020-12/schema',
+    title: 'BroTableSpec',
+    description: 'A Table, Bro table as data: columns, custom cells, filters, rows, config and CSS variables, without functions and without the tags of a skin',
+    type: 'object',
+    properties: {
+        specVersion: { const: 1 },
+        rowType: { type: 'string', description: 'The name of the type of a row in PascalCase, as Order' },
+        fields: {
+            type: 'array',
+            description: 'The fields of a row',
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'An identifier, as customerName' },
+                    type: { enum: ['string', 'number', 'boolean', 'string[]'] },
+                    values: { type: 'array', items: string, description: 'All values of a string field: the rows take only them, a select filter offers them' },
+                    source: { type: 'string', description: 'With an API: the path of the value in an item of its answer, as price or meta.createdAt' }
+                },
+                required: ['name', 'type'],
+                additionalProperties: false
+            }
+        },
+        cols: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    title: string,
+                    name: { type: 'string', description: 'The field of the row the column shows' },
+                    shortTitle: { type: 'string', description: 'The title for the narrowest width of the column; the default is the first word of the title' },
+                    tooltip: string,
+                    dataType: { enum: ['string', 'number', 'boolean'], description: 'By default the type of the field' },
+                    sortKey: { type: 'string', description: 'The field the column sorts by' },
+                    component: {
+                        description: 'A custom cell of cells, or a ready element of the skins: tags, switch or details-button',
+                        oneOf: [
+                            { type: 'object', properties: { cell: string }, required: ['cell'], additionalProperties: false },
+                            { type: 'object', properties: { element: { enum: ['tags', 'switch', 'details-button'] } }, required: ['element'], additionalProperties: false }
+                        ]
+                    }
+                },
+                required: ['title'],
+                additionalProperties: false
+            }
+        },
+        cells: {
+            type: 'array',
+            description: 'The contracts of the custom cells and of the row details',
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'In kebab-case, as status' },
+                    kind: { enum: ['cell', 'details'], description: 'A cell of a column, or the element of the row details' },
+                    shows: { type: 'string', description: 'What the cell shows, in words' },
+                    fields: { type: 'array', items: string, description: 'The fields of the row the cell reads' },
+                    actions: { type: 'array', items: string, description: 'The actions the cell sends, as edit' }
+                },
+                required: ['name', 'shows', 'fields'],
+                additionalProperties: false
+            }
+        },
+        filters: {
+            type: 'array',
+            description: 'The filters of the Filter Drawer next to the table',
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'The key in the object of the filters; a range has the keys <name>From and <name>To' },
+                    label: string,
+                    control: { enum: ['text', 'select', 'range', 'checkbox'] },
+                    field: { type: 'string', description: 'The field of the row the filter compares' },
+                    match: { enum: ['contains', 'startsWith', 'eq', 'custom'], description: 'text: contains or startsWith; select and checkbox: eq; range compares itself' },
+                    rule: { type: 'string', description: 'The rule of the match custom, in words' }
+                },
+                required: ['name', 'label', 'control'],
+                additionalProperties: false
+            }
+        },
+        rows: {
+            type: 'array',
+            description: 'The rows of the spec: objects with the fields of the row',
+            items: { type: 'object' }
+        },
+        config: {
+            type: 'object',
+            properties: {
+                toolbarTitle: string,
+                pageSize: { type: 'integer', minimum: 1, description: 'The rows on a page' },
+                server: { type: 'boolean', description: 'The rows come from the server by the query of the table' },
+                rowCounter: boolean,
+                shadowsEnabled: boolean,
+                theme: { enum: ['light', 'dark', 'auto'] },
+                rowDetailsComponent: { type: 'object', properties: { cell: string }, required: ['cell'], additionalProperties: false, description: 'A cell of the kind details' },
+                rowDetailsServer: boolean,
+                rowDetailsMotion: { enum: ['kinetic', 'eased'], description: 'The motion of the row details: kinetic by default, eased opens them in --bro-details-duration' }
+            },
+            additionalProperties: false
+        },
+        toolbar: {
+            type: 'object',
+            properties: {
+                buttons: { type: 'array', items: button },
+                menu: {
+                    type: 'object',
+                    properties: { title: string, items: { type: 'array', items: button } },
+                    required: ['title', 'items'],
+                    additionalProperties: false
+                }
+            },
+            additionalProperties: false
+        },
+        stateMessages: {
+            type: 'object',
+            properties: { loading: string, 'no-data': string, 'not-found': string, fail: string },
+            additionalProperties: false
+        },
+        skinConfig: {
+            type: 'object',
+            description: 'The settings of the components of one skin, with the names of BroConfig',
+            properties: Object.fromEntries(['mat', 'bs', 'nv'].map(skin => [skin, {
+                    type: 'object',
+                    properties: {
+                        css: { type: 'object', description: 'Values of BroConfig.css' },
+                        components: { type: 'object', description: 'Values of BroConfig.components, without functions' },
+                        callbacks: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    path: { type: 'string', description: 'The path of the function, as components.sortHeader.afterRender' },
+                                    does: { type: 'string', description: 'What the function does, in words' }
+                                },
+                                required: ['path', 'does'],
+                                additionalProperties: false
+                            }
+                        }
+                    },
+                    additionalProperties: false
+                }])),
+            additionalProperties: false
+        },
+        api: {
+            type: 'object',
+            description: 'The GET endpoint that gives the rows',
+            properties: {
+                url: { type: 'string', description: 'The address of the endpoint, http or https' },
+                rows: { type: 'string', description: 'The path of the array of the rows in the answer, as products; empty for an answer that is the array' },
+                paging: {
+                    type: 'object',
+                    description: 'An API that gives the rows page by page: the query parameters of the size of a page and of its offset or number',
+                    properties: { size: string, offset: string, page: string },
+                    required: ['size'],
+                    additionalProperties: false
+                },
+                total: { type: 'string', description: 'The path of the number of all rows in the answer of a page, as total: an API that gives pages has it' },
+                search: { type: 'string', description: 'An API that gives pages: the query parameter of its text search, as search' },
+                sort: {
+                    type: 'object',
+                    description: 'An API that gives pages: the query parameters of the sort, of the field and of the direction, asc or desc; without order a minus before the field sorts down',
+                    properties: { field: string, order: string },
+                    required: ['field'],
+                    additionalProperties: false
+                },
+                filters: {
+                    type: 'object',
+                    description: 'An API that gives pages: the query parameter of every key of the filters, as {"newsSite": "news_site"}; a range has the keys <name>From and <name>To',
+                    additionalProperties: string
+                }
+            },
+            required: ['url', 'rows'],
+            additionalProperties: false
+        },
+        cssVars: {
+            type: 'object',
+            description: 'The CSS variables of the table',
+            properties: Object.fromEntries(cssVariables.map(variable => [variable.name, { type: 'string', description: variable.description }])),
+            additionalProperties: false
+        }
+    },
+    required: ['specVersion', 'rowType', 'fields', 'cols'],
+    additionalProperties: false
+};
+/** The JSON Schema of a filter of the Filter Drawer, as in the spec. */
+export const filterSchema = specSchema['properties']['filters']['items'];
+/** The JSON Schema of the filling of one cell or of the row details, BroCellFilling, for the tools of the MCP server. */
+export const cellFillingSchema = {
+    type: 'object',
+    properties: {
+        imports: {
+            type: 'array',
+            description: 'Angular: the components of the project that the template uses; the classes of Angular Material and the pipes of Angular come from the template',
+            items: {
+                anyOf: [
+                    { type: 'object', properties: { name: string, from: { type: 'string', description: 'The path of the module, as ./order-badge' } }, required: ['name', 'from'], additionalProperties: false },
+                    { type: 'string', description: 'The name of a class of Angular Material or of a pipe of Angular, as DatePipe' }
+                ]
+            }
+        },
+        template: { type: 'string', description: 'Angular: the template of the component, in every skin' },
+        styles: { type: 'string', description: 'Angular: the styles of the component' },
+        render: { type: 'string', description: 'Vanilla JS: the body of render(), which builds the DOM of the cell' },
+        members: { type: 'string', description: 'The members of the class: computed values, handlers' }
+    },
+    additionalProperties: false
+};
+const skinBodies = { type: 'object', additionalProperties: string };
+/** The JSON Schema of BroSpecFillings, the parts of the code that a model writes, for the tools of the MCP server. */
+export const fillingsSchema = {
+    title: 'BroSpecFillings',
+    description: 'The parts of the code that you write: the templates of the cells, the rules of the custom filters and the bodies of the functions of the skin config; get_docs, topic fillings',
+    type: 'object',
+    properties: {
+        cells: {
+            type: 'object',
+            description: 'The cells and the row details by their names, for each skin',
+            additionalProperties: { type: 'object', properties: { mat: cellFillingSchema, bs: cellFillingSchema, nv: cellFillingSchema }, additionalProperties: false }
+        },
+        filterRules: { type: 'object', description: 'The conditions of the filters with the match custom, by their names: the body of (row, value) => boolean', additionalProperties: string },
+        callbacks: {
+            type: 'object',
+            description: 'The bodies of the functions of the skin config, by the skin and the path, as components.sortHeader.afterRender',
+            properties: { mat: skinBodies, bs: skinBodies, nv: skinBodies },
+            additionalProperties: false
+        }
+    },
+    additionalProperties: false
+};
+/**
+ * The JSON Schema of the rows for the fields of a spec. A strict schema of a model has no object with free keys, so
+ * the site asks the model for the rows by this schema, after the spec: every value gets the type of its field.
+ */
+export function rowsSchema(fields) {
+    return {
+        type: 'object',
+        properties: {
+            rows: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: Object.fromEntries(fields.map(field => [field.name, fieldSchema(field)])),
+                    required: fields.map(field => field.name),
+                    additionalProperties: false
+                }
+            }
+        },
+        required: ['rows'],
+        additionalProperties: false
+    };
+}
+function fieldSchema(field) {
+    const value = field.values ? { type: 'string', enum: field.values } : { type: 'string' };
+    switch (field.type) {
+        case 'string[]':
+            return { type: 'array', items: value };
+        case 'string':
+            return value;
+        default:
+            return { type: field.type };
+    }
+}

package/dist/spec/skin-config.d.ts

@@ -0,0 +1,30 @@
+import type { BroSpecSkin } from './spec.js';
+/**
+ * The values of BroConfig['css'] and BroConfig['components'] a spec may set for one skin, by the types of Table, Bro
+ * (types/table-bro.ts). The config of the application lies over a copy of the config of the skin, so it may change
+ * any of them before init, without a new build of the skin: nested objects are merged, arrays are replaced.
+ */
+export type BroSkinConfigShape = 'string' | 'boolean' | 'state' | {
+    [key: string]: BroSkinConfigShape;
+};
+export declare const skinConfigShape: {
+    css: BroSkinConfigShape;
+    components: BroSkinConfigShape;
+};
+/** The fields of the config that the spec gives in other places: the generator writes them from there. */
+export declare const skinConfigElsewhere: Record<string, string>;
+/**
+ * The contracts of the elements of a skin: a custom element in place of one of them follows its contract,
+ * a type of Table, Bro. The application defines the element, the generator does not write it.
+ */
+export declare const skinElementContracts: Record<string, string>;
+export interface BroSkinCallback {
+    path: string;
+    signature: string;
+    /** The skins that call it: the elements of the mat skin are Angular components and call none of their own. */
+    skins: BroSpecSkin[];
+    description: string;
+}
+export declare const skinCallbacks: BroSkinCallback[];
+/** Functions of the config that the config of a table cannot change, with the reason. */
+export declare const skinCallbacksElsewhere: Record<string, string>;

package/dist/spec/skin-config.js

@@ -0,0 +1,67 @@
+const className = { className: 'string' };
+const states = { loading: 'state', 'no-data': 'state', 'not-found': 'state', fail: 'state' };
+export const skinConfigShape = {
+    css: {
+        table: {
+            className: 'string',
+            thead: { className: 'string', tr: { className: 'string', th: className } },
+            tbody: { className: 'string', tr: { className: 'string', td: className } }
+        },
+        shadow: className
+    },
+    components: {
+        button: { selector: 'string', iconSelector: 'string' },
+        dropdown: { selector: 'string', css: { button: className } },
+        paginator: {
+            selector: 'string',
+            inputsAsProperties: 'boolean',
+            recreateOnReplaceRows: 'boolean',
+            css: { ul: { className: 'string', li: { className: 'string', a: className } } }
+        },
+        progressBar: { selector: 'string' },
+        sortHeader: { selector: 'string', titleAsContent: 'boolean', contentSelector: 'string' },
+        state: { fontIcon: 'boolean', lottie: 'boolean', states, statesDark: states },
+        switch: { selector: 'string', css: { div: { className: 'string', input: className } } },
+        textEllipsis: { selector: 'string' },
+        toolbar: { selector: 'string', css: { nav: { className: 'string', div: className } } },
+        toolbarMain: {
+            selector: 'string',
+            css: {
+                toolbarTitle: className,
+                navbarCollapse: { className: 'string', ul: { className: 'string', li: { className: 'string', a: className } } }
+            }
+        }
+    }
+};
+/** The fields of the config that the spec gives in other places: the generator writes them from there. */
+export const skinConfigElsewhere = {
+    'components.toolbarMain.buttons': 'the buttons of the toolbar go into toolbar of the spec'
+};
+/**
+ * The contracts of the elements of a skin: a custom element in place of one of them follows its contract,
+ * a type of Table, Bro. The application defines the element, the generator does not write it.
+ */
+export const skinElementContracts = {
+    button: 'BroButton',
+    dropdown: 'BroDropdown',
+    paginator: 'BroPaginatorElement',
+    progressBar: 'BroProgressBar',
+    sortHeader: 'BroSortHeader',
+    textEllipsis: 'BroTextEllipsis',
+    toolbar: 'BroToolbarElement',
+    toolbarMain: 'BroToolbarMain'
+};
+export const skinCallbacks = [
+    { path: 'components.button.beforeRender', signature: '(element: Element, value: string) => void', skins: ['mat', 'bs', 'nv'], description: 'before the details button of the core renders' },
+    { path: 'components.sortHeader.beforeRender', signature: '(element: Element, value: string) => void', skins: ['mat', 'bs', 'nv'], description: 'before the header of a column renders' },
+    { path: 'components.sortHeader.afterRender', signature: '(element: Element, value: string) => void | (() => void)', skins: ['bs', 'nv'], description: 'after the header of a column renders, for example to add a tooltip; a returned function cleans up' },
+    { path: 'components.textEllipsis.afterRender', signature: '(element: Element, value: string) => void | (() => void)', skins: ['bs', 'nv'], description: 'after a cut value renders, for example to add a tooltip; a returned function cleans up' },
+    { path: 'components.toolbarMain.beforeRender', signature: '(searchButton: Element, value: string) => void', skins: ['bs', 'nv'], description: 'before the search button of the toolbar renders; value is its word, texts.toolbarMain.search' },
+    { path: 'components.toolbarSearch.beforeRender', signature: '(backButton: Element, clearButton: Element) => void', skins: ['mat', 'bs', 'nv'], description: 'before the buttons of the search line render' },
+    { path: 'components.fontIcon.html', signature: '(iconName: string) => string', skins: ['mat', 'bs', 'nv'], description: 'the markup of a state icon with components.state.fontIcon' },
+    { path: 'components.state.lottieHTML', signature: '(iconSrc: string) => string', skins: ['mat', 'bs', 'nv'], description: 'the markup of a state icon with components.state.lottie' }
+];
+/** Functions of the config that the config of a table cannot change, with the reason. */
+export const skinCallbacksElsewhere = {
+    'components.filterDrawer.beforeRender': 'the Filter Drawer is outside of the table and takes it from the registered config of the skin, not from the config of the table'
+};

package/dist/spec/spec.d.ts

@@ -0,0 +1,157 @@
+/** An identifier of JavaScript: the names of the fields, the cells and the filters, and a key of an object literal. */
+export declare const specIdentifier: RegExp;
+/**
+ * BroTableSpec: the table as data, without functions and without the tags of a skin. It repeats the names of BroCol and
+ * BroConfig of Table, Bro, so a model and a developer learn no second vocabulary. The generator writes the code of the
+ * table from it for a target and a skin, and the site renders it with the switch of the skins.
+ */
+export interface BroTableSpec {
+    /** The version of this format. */
+    specVersion: 1;
+    /** The name of the type of a row, as Order: the generator writes the type with it. */
+    rowType: string;
+    /** The fields of a row: the type of the row, the schema of the rows on the site, the checks of the columns. */
+    fields: BroSpecField[];
+    cols: BroSpecCol[];
+    /** The contracts of the custom cells and of the row details: what they show, read, and send. */
+    cells?: BroSpecCell[];
+    /** The filters of the Filter Drawer next to the table. */
+    filters?: BroSpecFilter[];
+    /** The rows of the spec; locally the generator writes the loading of the data without them. */
+    rows?: BroSpecRow[];
+    config?: BroSpecConfig;
+    /** The buttons and the menu of the toolbar of the table. */
+    toolbar?: BroSpecToolbar;
+    /** The messages of the states of the table; every skin keeps its own icon. */
+    stateMessages?: Partial<Record<BroSpecState, string>>;
+    /** The settings of the components of one skin, with the names of the fields of BroConfig. */
+    skinConfig?: Partial<Record<BroSpecSkin, BroSpecSkinConfig>>;
+    /** The CSS custom properties of the table, as --bro-row-height: 64px. */
+    cssVars?: Record<string, string>;
+    /** The GET endpoint that gives the rows; the source of every field is the path of its value in an item of the answer. */
+    api?: BroSpecApi;
+}
+export interface BroSpecApi {
+    /** The address of the endpoint, http or https. */
+    url: string;
+    /** The path of the array of the rows in the answer, as products or data.items; empty for an answer that is the array. */
+    rows: string;
+    /** An API that gives the rows page by page: the query parameters of the size of a page and of its offset or number. */
+    paging?: {
+        size: string;
+        offset?: string;
+        page?: string;
+    };
+    /** The path of the number of all rows in the answer of a page, as total: an API that gives pages has it. */
+    total?: string;
+    /** An API that gives pages also searches, sorts and filters: the query parameter of its text search, as search. */
+    search?: string;
+    /** The query parameters of the sort: of the field, and of the direction, asc or desc; without it a minus before the field sorts down. */
+    sort?: {
+        field: string;
+        order?: string;
+    };
+    /** The query parameter of every key of the filters, as {"newsSite": "news_site"}; a range has the keys <name>From and <name>To. */
+    filters?: Record<string, string>;
+}
+export type BroSpecSkin = 'mat' | 'bs' | 'nv';
+export type BroSpecFieldType = 'string' | 'number' | 'boolean' | 'string[]';
+export interface BroSpecField {
+    /** An identifier: it becomes a field of the type of the row. */
+    name: string;
+    type: BroSpecFieldType;
+    /** All values of a string field: the rows take only them, a select filter offers them, a cell knows every variant. */
+    values?: string[];
+    /** With an API: the path of the value in an item of its answer, as price or meta.createdAt. */
+    source?: string;
+}
+export interface BroSpecCol {
+    title: string;
+    /** The field of the row the column shows; a column of a custom cell may have none. */
+    name?: string;
+    /** The title for the narrowest width of the column; the default is the first word of the title. */
+    shortTitle?: string;
+    tooltip?: string;
+    dataType?: 'string' | 'number' | 'boolean';
+    sortKey?: string;
+    component?: BroSpecColComponent;
+}
+/** A custom cell by the name of its contract, or a ready element of the skins: its tag depends on the skin. */
+export type BroSpecColComponent = {
+    cell: string;
+} | {
+    element: BroSpecElement;
+};
+export type BroSpecElement = 'tags' | 'switch' | 'details-button';
+export interface BroSpecCell {
+    /** In kebab-case: a part of the tag, the class, and the file of the component. */
+    name: string;
+    /** A cell of a column, or the element of the row details named by config.rowDetailsComponent. */
+    kind?: 'cell' | 'details';
+    /** What the cell shows, in words: the task for its template. */
+    shows: string;
+    /** The fields of the row the cell reads. */
+    fields: string[];
+    /** The actions the cell sends: the page tells them by event.action. */
+    actions?: string[];
+}
+export type BroSpecFilterControl = 'text' | 'select' | 'range' | 'checkbox';
+export type BroSpecFilterMatch = 'contains' | 'startsWith' | 'eq' | 'custom';
+export interface BroSpecFilter {
+    /** The key in the object of the filters; a range has the keys <name>From and <name>To. */
+    name: string;
+    label: string;
+    control: BroSpecFilterControl;
+    /** The field of the row the filter compares; a custom rule may read other fields. */
+    field?: string;
+    /** How the value matches the field; a range compares with gte and lte. */
+    match?: BroSpecFilterMatch;
+    /** The rule of a custom match in words: the model writes the condition for one row. */
+    rule?: string;
+}
+export type BroSpecRow = Record<string, string | number | boolean | string[] | null>;
+export interface BroSpecConfig {
+    toolbarTitle?: string;
+    pageSize?: number;
+    server?: boolean;
+    rowCounter?: boolean;
+    shadowsEnabled?: boolean;
+    theme?: 'light' | 'dark' | 'auto';
+    /** The custom element of the row details: a cell of the kind details. */
+    rowDetailsComponent?: {
+        cell: string;
+    };
+    rowDetailsServer?: boolean;
+    /** The motion of the row details: kinetic by default, as the pages move; eased opens them in --bro-details-duration. */
+    rowDetailsMotion?: 'kinetic' | 'eased';
+}
+export interface BroSpecToolbar {
+    buttons?: BroSpecToolbarButton[];
+    /** One menu: the toolbar of the mat skin shows one. */
+    menu?: {
+        title: string;
+        items: BroSpecToolbarButton[];
+    };
+}
+export interface BroSpecToolbarButton {
+    title: string;
+    /** The action of the bro-action event on a click. */
+    action: string;
+    /** The name of a Material icon: a button of the toolbar of the mat skin is an icon. */
+    icon?: string;
+}
+export type BroSpecState = 'loading' | 'no-data' | 'not-found' | 'fail';
+export interface BroSpecSkinConfig {
+    /** Values of BroConfig['css']. */
+    css?: Record<string, unknown>;
+    /** Values of BroConfig['components'], without functions. */
+    components?: Record<string, unknown>;
+    /** The functions of the skin config: the model writes their bodies. */
+    callbacks?: BroSpecCallback[];
+}
+export interface BroSpecCallback {
+    /** The path of the function in the config, as components.sortHeader.afterRender. */
+    path: string;
+    /** What the function does, in words. */
+    does: string;
+}

package/dist/spec/spec.js

@@ -0,0 +1,2 @@
+/** An identifier of JavaScript: the names of the fields, the cells and the filters, and a key of an object literal. */
+export const specIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;

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

@@ -0,0 +1,54 @@
+import type { BroMcpExtension } from '../extension.js';
+import { type BroSpecSkin } from './spec.js';
+export interface BroSpecIssue {
+    /** The path of the field in the spec, as cols[3].component.cell; empty for the spec itself. */
+    path: string;
+    /** What is wrong. */
+    message: string;
+    /** How it should be, when it is known. */
+    fix?: string;
+}
+export interface BroSpecReport {
+    valid: boolean;
+    errors: BroSpecIssue[];
+    warnings: BroSpecIssue[];
+    /** The issues after the first 100 errors and the first 100 warnings, which the report leaves out. */
+    omitted?: {
+        errors?: number;
+        warnings?: number;
+    };
+}
+/** The sizes that a host of the generator renders: a strict JSON Schema of a model checks no sizes. */
+export interface BroSpecLimits {
+    cols?: number;
+    rows?: number;
+    cells?: number;
+    filters?: number;
+    /** The length of a string value of a row. */
+    valueLength?: number;
+}
+export interface BroValidateOptions {
+    /** The skin of the project; without it the spec is checked for the three skins. */
+    skin?: BroSpecSkin;
+    /** A host that renders the table of the spec, as a preview, requires its rows. */
+    rowsRequired?: boolean;
+    limits?: BroSpecLimits;
+    /** The paid modules of the project: their fields of the config are known. */
+    extensions?: BroMcpExtension[];
+}
+export declare class BroSpecIssues {
+    readonly errors: BroSpecIssue[];
+    readonly warnings: BroSpecIssue[];
+    error(path: string, message: string, fix?: string): void;
+    warning(path: string, message: string, fix?: string): void;
+}
+/**
+ * Every table has row details by default: validate_spec and generate_code warn about a table without them, as a request
+ * may ask for such a table.
+ */
+export declare function rowDetailsByDefault(spec: unknown): BroSpecIssue[];
+/**
+ * Checks a table spec and tells for every problem where it is, what is wrong and how it should be. The site runs it
+ * on every answer of the model, the MCP server before the generator.
+ */
+export declare function validateSpec(spec: unknown, options?: BroValidateOptions): BroSpecReport;