@stonecrop/schema 0.30.0 → 0.32.0

package/dist/src/column-schema.d.ts

@@ -1,163 +0,0 @@
-import type { FieldOptions } from './field';
-/**
- * Authoring contract for doctype field declarations that can be rendered as table columns.
- * Pass a `ColumnSchema[]` array to ATable's `:schema` prop; `schemaToColumns` converts it
- * to `TableColumn[]` internally — callers working from a doctype schema never need to
- * construct `TableColumn` directly.
- *
- * Notes on specific properties:
- * - `align` uses an explicit string union rather than `CanvasTextAlign` — this package is
- *   used server-side by the CLI where browser DOM types are absent. The values are identical.
- * - `format` is a serialized function string; the table store's `getFormattedValue` deserializes
- *   it via `Function(...)`. `TableColumn.format` widens this to also accept a live function.
- * - `mask` is absent — it is function-typed only and cannot be serialized to JSON. It lives
- *   exclusively on `TableColumn`.
- * - `modalComponent` is string-only — functions cannot appear in schema JSON. `TableColumn`
- *   widens this to also accept a factory function.
- *
- * @public
- */
-export interface ColumnSchema {
-    /** Unique identifier for the field within its doctype. Maps to `name` on `TableColumn`. */
-    fieldname: string;
-    /**
-     * Rendering component (e.g. `'ATextInput'`, `'ANumericInput'`, `'ADate'`). Default cell
-     * formatting and filter widgets derive from its {@link ComponentCategory}.
-     *
-     * Optional here, unlike `ValueField.component`: absence is what marks an entry as non-scalar
-     * (a nested table or fieldset), which `schemaToColumns` excludes — it has no column equivalent.
-     */
-    component?: string;
-    /**
-     * Target doctype slug — marks this column as a link. When set and no `cellComponent` is given,
-     * `schemaToColumns` copies it to `TableColumn.linkDoctype`, which ACell uses to resolve a bare
-     * id to display text.
-     */
-    doctype?: string;
-    /**
-     * Human-readable column header. When absent, ATable assigns labels alphabetically
-     * (A, B, C, …).
-     */
-    label?: string;
-    /** When `true`, the field is excluded from the derived columns by `schemaToColumns`. */
-    hidden?: boolean;
-    /**
-     * Horizontal text alignment for the column cell and header.
-     *
-     * @defaultValue 'center'
-     */
-    align?: 'left' | 'right' | 'center' | 'start' | 'end';
-    /**
-     * Whether the column cell is editable in the table.
-     *
-     * @defaultValue false
-     */
-    edit?: boolean;
-    /**
-     * CSS width of the column (e.g. `'20ch'`, `'200px'`).
-     *
-     * @defaultValue '40ch'
-     */
-    width?: string;
-    /**
-     * When `true`, the column is pinned to the left side of the table.
-     *
-     * @defaultValue false
-     */
-    pinned?: boolean;
-    /**
-     * When `true`, the column can be resized by dragging the header edge.
-     *
-     * @defaultValue false
-     */
-    resizable?: boolean;
-    /**
-     * When `true`, clicking the column header sorts the table by this column.
-     *
-     * @defaultValue true
-     */
-    sortable?: boolean;
-    /**
-     * When `true`, a filter control is rendered in the column header.
-     *
-     * @defaultValue true
-     */
-    filterable?: boolean;
-    /**
-     * The type of filter control to render. When absent, a default is derived from the
-     * `component`'s {@link ComponentCategory} (`boolean` → `checkbox`, `date` → `date`,
-     * `datetime` → `dateRange`, `select` → `select`, `number` → `number`, everything else
-     * — including an unknown component — → `text`).
-     */
-    filterType?: 'text' | 'select' | 'number' | 'date' | 'dateRange' | 'checkbox' | 'component';
-    /**
-     * Static option list for `filterType: 'select'`. When absent, options are derived from
-     * the unique values present in the column's rows.
-     */
-    filterOptions?: any[];
-    /** Registered component name used when `filterType` is `'component'`. */
-    filterComponent?: string;
-    /**
-     * Registered component name rendered inside the table cell instead of the default display.
-     * When absent, the table renders the value as plain text in a `<td>`.
-     */
-    cellComponent?: string;
-    /**
-     * Additional props passed to `cellComponent`.
-     *
-     * Only applicable when `cellComponent` is set.
-     */
-    cellComponentProps?: Record<string, any>;
-    /**
-     * Registered component name rendered in the cell's modal editor. String-only — functions
-     * cannot appear in schema JSON. `TableColumn.modalComponent` widens this to also accept a
-     * factory function.
-     *
-     * The following props are automatically passed to the modal component:
-     * - `colIndex` — the column index of the current cell
-     * - `rowIndex` — the row index of the current cell
-     * - `store` — the table data store
-     */
-    modalComponent?: string;
-    /**
-     * Extra props passed to `modalComponent` in addition to the standard cell props.
-     *
-     * Only applicable when `modalComponent` is set.
-     */
-    modalComponentExtraProps?: Record<string, any>;
-    /**
-     * Type-specific field options — Select choices, badge maps, quantity/currency config, etc.
-     * Spreads through `schemaToColumns` to `TableColumn`.
-     */
-    options?: FieldOptions;
-    /**
-     * Serialized function string used to format the cell value for display. Deserialized at
-     * render time by the table store's `getFormattedValue`. May return a plain string, HTML, or a
-     * {@link BadgeDescriptor}. `TableColumn.format` widens this to also accept a live function.
-     */
-    format?: string;
-    /**
-     * When `true`, this column is treated as a Gantt bar column.
-     *
-     * Only applicable for Gantt tables.
-     *
-     * @defaultValue false
-     */
-    isGantt?: boolean;
-    /**
-     * Registered component name used to render Gantt bars in this column.
-     *
-     * Only applicable for Gantt tables.
-     *
-     * @defaultValue 'AGanttCell'
-     */
-    ganttComponent?: string;
-    /**
-     * Number of columns this Gantt bar spans across. When absent, the bar stretches to cover
-     * all non-pinned columns in the table.
-     *
-     * Only applicable for Gantt tables.
-     */
-    colspan?: number;
-}
-//# sourceMappingURL=column-schema.d.ts.map

package/dist/src/column-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"column-schema.d.ts","sourceRoot":"","sources":["../../src/column-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,YAAY;IAC5B,2FAA2F;IAC3F,SAAS,EAAE,MAAM,CAAA;IAEjB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd,wFAAwF;IACxF,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAA;IAErD;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IAEd;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IAEpB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAA;IAE3F;;;OAGG;IACH,aAAa,CAAC,EAAE,GAAG,EAAE,CAAA;IAErB,yEAAyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAA;IAExB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAExC;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAE9C;;;OAGG;IACH,OAAO,CAAC,EAAE,YAAY,CAAA;IAEtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CAChB"}

package/dist/src/component-meta.d.ts

@@ -1,96 +0,0 @@
-/**
- * Semantic category for a rendering component.
- *
- * `component` is the primary field axis, so the runtime consumers that need to know what a field
- * *means* (atable cell formatting / filter widgets, record-default init) derive it from here. This
- * is the single source of "what kind of value does this component render", keyed by the canonical
- * registered component names — each consumer maps the category to its own concern (filter widget,
- * default value, …).
- *
- * @public
- */
-export type ComponentCategory = 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'select' | 'code' | 'link' | 'attach' | 'quantity' | 'currency';
-/**
- * Canonical component → semantic category. Only the components Stonecrop ships with appear here;
- * custom/unknown component names have no category and consumers fall back to their default.
- * @public
- */
-export declare const COMPONENT_CATEGORY: Record<string, ComponentCategory>;
-/**
- * Resolve a component's semantic category, or `undefined` for an unknown (custom) component —
- * callers treat that as "no opinion" and use their own default.
- * @public
- */
-export declare function componentCategory(component?: string): ComponentCategory | undefined;
-/**
- * Whether a link component expands its target doctype, or renders the link inline.
- *
- * This is the *only* axis the component decides. It deliberately does not choose between an
- * embedded record and an embedded table: `cardinality` states whether the value is a scalar or
- * an array, which is a fact about the data rather than a rendering preference, so a component
- * must not be able to override it (an `AForm` over a `noneOrMany` link would be handed an array
- * it cannot render). Component names encode both axes — `AFormLink`/`ATableLink` are the inline
- * pair, `AForm`/`ATable` the expanding pair — but only the inline/expand half is authoritative.
- *
- * @public
- */
-export type LinkExpansion = 'inline' | 'expand';
-/**
- * Canonical link component → expansion. Only components Stonecrop ships with appear here; an
- * unmapped (custom) component has none, and callers treat that as `expand` — the behaviour that
- * predates this map, so a custom component can never silently collapse a link to a picker.
- * @public
- */
-export declare const COMPONENT_LINK_EXPANSION: Record<string, LinkExpansion>;
-/**
- * Resolve a component's link expansion, or `undefined` for an absent/unmapped component.
- * @public
- */
-export declare function componentLinkExpansion(component?: string): LinkExpansion | undefined;
-/**
- * How a link field renders.
- *
- * - `inline` — a scalar id-picker; the target is *not* expanded (the field keeps its own value
- *   and carries a `doctype` prop for async display-text resolution and navigation).
- * - `record` — the target doctype is resolved and embedded as a nested form.
- * - `table` — the target doctype is resolved and embedded as a child table.
- *
- * @public
- */
-export type LinkRenderMode = 'inline' | 'record' | 'table';
-/**
- * Decide how a *declared* link (one with a `LinkDeclaration`) renders.
- *
- * Two independent axes: the **component** picks inline vs expand, and when expanding the
- * **cardinality** picks record vs table (many → table). The declaration's component wins over the
- * field's, matching the precedence the resolver already uses for the rendered component.
- *
- * This is the single definition of "does this link expand" — it is consumed by both the client
- * resolver (which builds the nested schema) and the server column builder (which must still
- * SELECT an `inline` link's FK column). Call it; never re-derive the rule at the call site, or
- * the two will drift and the client will render a table for a column the server never selected.
- *
- * @param link - the link declaration (only `component` and `cardinality` are consulted)
- * @param fieldComponent - the linked field's own `component`, used when the declaration names none
- * @public
- */
-export declare function resolveLinkRenderMode(link: {
-    component?: string;
-    cardinality?: string;
-}, fieldComponent?: string): LinkRenderMode;
-/**
- * Every component Stonecrop ships with that can render a value field, sorted by name.
- *
- * The union of the two maps above is the definition, not a copy of it: a shipped component either
- * categorises a value ({@link COMPONENT_CATEGORY}) or is one of the link containers that has no
- * value of its own ({@link COMPONENT_LINK_EXPANSION}'s `AForm`/`ATable`). `AFieldset` is absent by
- * the same rule — it is a `kind: 'fieldset'` container, so it is never a value field's component.
- *
- * `component` is an **open** axis: any string is valid, and naming a custom component is how an app
- * renders a field Stonecrop ships no widget for. This list is therefore the set to *suggest* to an
- * author, and to check first-party data against — never a set to validate arbitrary input against.
- *
- * @public
- */
-export declare const CANONICAL_COMPONENTS: readonly string[];
-//# sourceMappingURL=component-meta.d.ts.map

package/dist/src/component-meta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-meta.d.ts","sourceRoot":"","sources":["../../src/component-meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAC5B,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAA;AAEtH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAkBhE,CAAA;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAEnF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAIlE,CAAA;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEpF;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAA;AAE1D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,EAClD,cAAc,CAAC,EAAE,MAAM,GACrB,cAAc,CAGhB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAEtC,CAAA"}

package/dist/src/component-meta.js

@@ -1,88 +0,0 @@
-/**
- * Canonical component → semantic category. Only the components Stonecrop ships with appear here;
- * custom/unknown component names have no category and consumers fall back to their default.
- * @public
- */
-export const COMPONENT_CATEGORY = {
-    ATextInput: 'text',
-    ATextboxInput: 'text',
-    ANumericInput: 'number',
-    ACheckbox: 'boolean',
-    ADate: 'date',
-    ADatePicker: 'date',
-    ADateSelection: 'date',
-    ADateTime: 'datetime',
-    ADuration: 'text',
-    ADateRange: 'date',
-    ADropdown: 'select',
-    ASegmentedControl: 'select',
-    ACodeEditor: 'code',
-    AFormLink: 'link',
-    AFileAttach: 'attach',
-    AQuantityInput: 'quantity',
-    ACurrencyInput: 'currency',
-};
-/**
- * Resolve a component's semantic category, or `undefined` for an unknown (custom) component —
- * callers treat that as "no opinion" and use their own default.
- * @public
- */
-export function componentCategory(component) {
-    return component ? COMPONENT_CATEGORY[component] : undefined;
-}
-/**
- * Canonical link component → expansion. Only components Stonecrop ships with appear here; an
- * unmapped (custom) component has none, and callers treat that as `expand` — the behaviour that
- * predates this map, so a custom component can never silently collapse a link to a picker.
- * @public
- */
-export const COMPONENT_LINK_EXPANSION = {
-    AFormLink: 'inline',
-    AForm: 'expand',
-    ATable: 'expand',
-};
-/**
- * Resolve a component's link expansion, or `undefined` for an absent/unmapped component.
- * @public
- */
-export function componentLinkExpansion(component) {
-    return component ? COMPONENT_LINK_EXPANSION[component] : undefined;
-}
-/**
- * Decide how a *declared* link (one with a `LinkDeclaration`) renders.
- *
- * Two independent axes: the **component** picks inline vs expand, and when expanding the
- * **cardinality** picks record vs table (many → table). The declaration's component wins over the
- * field's, matching the precedence the resolver already uses for the rendered component.
- *
- * This is the single definition of "does this link expand" — it is consumed by both the client
- * resolver (which builds the nested schema) and the server column builder (which must still
- * SELECT an `inline` link's FK column). Call it; never re-derive the rule at the call site, or
- * the two will drift and the client will render a table for a column the server never selected.
- *
- * @param link - the link declaration (only `component` and `cardinality` are consulted)
- * @param fieldComponent - the linked field's own `component`, used when the declaration names none
- * @public
- */
-export function resolveLinkRenderMode(link, fieldComponent) {
-    if (componentLinkExpansion(link.component ?? fieldComponent) === 'inline')
-        return 'inline';
-    return link.cardinality === 'noneOrMany' || link.cardinality === 'atLeastOne' ? 'table' : 'record';
-}
-/**
- * Every component Stonecrop ships with that can render a value field, sorted by name.
- *
- * The union of the two maps above is the definition, not a copy of it: a shipped component either
- * categorises a value ({@link COMPONENT_CATEGORY}) or is one of the link containers that has no
- * value of its own ({@link COMPONENT_LINK_EXPANSION}'s `AForm`/`ATable`). `AFieldset` is absent by
- * the same rule — it is a `kind: 'fieldset'` container, so it is never a value field's component.
- *
- * `component` is an **open** axis: any string is valid, and naming a custom component is how an app
- * renders a field Stonecrop ships no widget for. This list is therefore the set to *suggest* to an
- * author, and to check first-party data against — never a set to validate arbitrary input against.
- *
- * @public
- */
-export const CANONICAL_COMPONENTS = [
-    ...new Set([...Object.keys(COMPONENT_CATEGORY), ...Object.keys(COMPONENT_LINK_EXPANSION)]),
-].toSorted();

package/dist/src/converter/aggregate.d.ts

@@ -1,127 +0,0 @@
-/**
- * Aggregate doctype derivation.
- *
- * A table gets two generated doctypes: the entity itself, whose `fields` carry every column and
- * which backs the record form, and an **aggregate** — the collection view over the same table.
- * The aggregate starts with identity alone, because the useful default for a collection is the
- * one column that lets a row be opened, not all forty. Widening it is curation, and curation
- * survives regeneration (see `mergeIntrospectedDoctype`).
- *
- * The two are peers: each is a complete doctype with its own `name` and `slug`, and nothing here
- * encodes a relationship between them. Deriving the aggregate's name from the entity's is a
- * generated encoding, not a readable one — no consumer recovers the pair by parsing a slug.
- *
- * @packageDocumentation
- */
-import type { ConvertedGraphQLDoctype } from './types';
-/**
- * The name an entity's aggregate doctype is generated under: the entity's name, pluralised.
- *
- * One definition, because the CLI writes the file under `toSlug` of this and any later caller
- * (a scaffolder, a docs generator) must land on the same name or it silently addresses a
- * different file.
- *
- * `pluralize` rather than appending `s`, because the irregulars are not rare in practice —
- * measured against a consumer's 41 hand-authored aggregate doctypes, this rule reproduces every
- * one of their names, slugs and filenames exactly, while `+ 's'` gets five wrong
- * (`Currencys`, `JournalEntrys`, …).
- *
- * The rule is not total: an already-plural name pluralises to itself. Callers must handle that —
- * see {@link buildAggregateDoctype}.
- *
- * @param doctypeName - the entity doctype's `name`
- * @returns the aggregate doctype's `name`
- * @public
- *
- * @example
- * ```typescript
- * aggregateDoctypeName('SalesOrder') // 'SalesOrders' -> slug 'sales-orders'
- * ```
- */
-export declare function aggregateDoctypeName(doctypeName: string): string;
-/**
- * Derive the aggregate doctype for a converted entity.
- *
- * Returns `undefined` when no identity column can be found — a natural-key table whose key the
- * converter refuses to guess and whose author has not declared one, or a foreign PostGraphile
- * endpoint that has left the Relay identifier occupying `id` (Stonecrop's own preset moves it to
- * `nodeId`). That is deliberate: an aggregate with an empty `fields` array is a valid doctype that
- * renders a table with no columns, which looks like a data problem rather than a generation one.
- * Emitting nothing and saying so is the loud failure.
- *
- * Identity resolves the same way `getRecordIdField` resolves it — the declared `primaryKey`, then
- * the conventional `id` — so an aggregate is always keyed on the column the client will later ask
- * for. `declaredIdentity` overrides both: SDL cannot express which `UNIQUE` column is the key, so
- * for a natural-key table the answer only exists in the authored file, and the caller that read it
- * passes the fieldname back.
- *
- * @param doctype - a converted entity doctype, as returned by `convertGraphQLSchema`
- * @param declaredIdentity - fieldname the authored doctype declares as its `primaryKey`, when the
- *   caller has read one. Must name a field the converter emitted; the caller checks that, because
- *   only it can say whether a missing one is a dropped column or a typo.
- * @returns the aggregate doctype, or `undefined` when no identity column exists
- * @public
- *
- * @example
- * ```typescript
- * const [order] = convertGraphQLSchema(sdl, { include: ['Order'] })
- * const aggregate = buildAggregateDoctype(order)
- * // { name: 'Orders', slug: 'orders', fields: [ the id field ] }
- * ```
- */
-export declare function buildAggregateDoctype(doctype: ConvertedGraphQLDoctype, declaredIdentity?: string): ConvertedGraphQLDoctype | undefined;
-/**
- * One file the generator will write, and what that file is verified against.
- *
- * `basis` exists because the two are not always the same document. An aggregate is written from
- * its own one-field generation but verified against the **entity**, since its purpose is to carry
- * fewer columns than the table — checking it against itself reports every curated column as one
- * the table had dropped.
- *
- * @public
- */
-export interface GenerationPlanEntry {
-    /** The doctype to write. */
-    generated: ConvertedGraphQLDoctype;
-    /** The doctype whose fields an existing file on disk is verified against. */
-    basis: ConvertedGraphQLDoctype;
-    /** Whether the file is a curated subset of `basis` — passed through to `MergeOptions.subset`. */
-    subset: boolean;
-}
-/** Options for {@link planGeneration}. @public */
-export interface GenerationPlanOptions {
-    /** Emit only the entity doctypes, skipping their aggregates. Defaults to `false`. */
-    noAggregates?: boolean;
-    /** Called with an advisory message for each entity that yields no aggregate. */
-    onWarning?: (message: string) => void;
-    /**
-     * Identity the authored doctype on disk declares, keyed by doctype `name`.
-     *
-     * SDL cannot say which `UNIQUE` column is a table's key, so for a natural-key table the converter
-     * derives nothing and the answer exists only in the file. Without this the aggregate is
-     * unreachable: generation says "declare a primaryKey and re-run", and re-running after declaring
-     * one changes nothing, because planning never reads the file.
-     *
-     * Passed in rather than read here so this stays a pure function of its inputs; the CLI owns the
-     * IO. The plan is then a function of the schema *and* what is already on disk.
-     */
-    identity?: Record<string, string>;
-}
-/**
- * Expand converted entities into the set of doctype files to write.
- *
- * Each table yields two: the entity, whose fields carry every column and which backs the record
- * form, and its aggregate — the collection view. They are written as peers, one file each, with
- * no key relating them.
- *
- * Separate from the CLI because the pairing of a file to its verification basis is the part that
- * is easy to get wrong and impossible to notice: getting it wrong does not throw, it just reports
- * drift that is not there, forever.
- *
- * @param entities - `convertGraphQLSchema` output
- * @param options - see {@link GenerationPlanOptions}
- * @returns one entry per file to write
- * @public
- */
-export declare function planGeneration(entities: readonly ConvertedGraphQLDoctype[], options?: GenerationPlanOptions): GenerationPlanEntry[];
-//# sourceMappingURL=aggregate.d.ts.map

package/dist/src/converter/aggregate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../src/converter/aggregate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,uBAAuB,EAChC,gBAAgB,CAAC,EAAE,MAAM,GACvB,uBAAuB,GAAG,SAAS,CAyBrC;AAkED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IACnC,4BAA4B;IAC5B,SAAS,EAAE,uBAAuB,CAAA;IAClC,6EAA6E;IAC7E,KAAK,EAAE,uBAAuB,CAAA;IAC9B,iGAAiG;IACjG,MAAM,EAAE,OAAO,CAAA;CACf;AAED,kDAAkD;AAClD,MAAM,WAAW,qBAAqB;IACrC,qFAAqF;IACrF,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,gFAAgF;IAChF,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,SAAS,uBAAuB,EAAE,EAC5C,OAAO,GAAE,qBAA0B,GACjC,mBAAmB,EAAE,CAmEvB"}