@eide/foir-cli 0.1.2 → 0.1.3

package/dist/cli.js

@@ -33,6 +33,7 @@ import { registerLocalesCommands } from './commands/locales.js';
 import { registerFilesCommands } from './commands/files.js';
 import { registerNotesCommands } from './commands/notes.js';
 import { registerVariantCatalogCommands } from './commands/variant-catalog.js';
+import { registerPullCommand } from './commands/pull.js';
 const program = new Command();
 program
     .name('foir')
@@ -74,4 +75,6 @@ registerLocalesCommands(program, getGlobalOpts);
 registerFilesCommands(program, getGlobalOpts);
 registerNotesCommands(program, getGlobalOpts);
 registerVariantCatalogCommands(program, getGlobalOpts);
+// Codegen
+registerPullCommand(program, getGlobalOpts);
 program.parse();

package/dist/codegen/fetch-models.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Fetches models from the platform GraphQL API and transforms them for codegen.
+ */
+import type { GraphQLClient } from 'graphql-request';
+import type { FieldSchemaForGen } from './field-mapping.js';
+export interface CodegenModelConfig {
+    records: boolean;
+    inline: boolean;
+    publicApi: boolean;
+    versioning: boolean;
+    publishing: boolean;
+    variants: boolean;
+    customerScoped: boolean;
+    embeddings?: {
+        enabled: boolean;
+        fields: Array<{
+            fieldPath: string;
+            weight?: number;
+        }>;
+    };
+}
+export interface CodegenModel {
+    key: string;
+    name: string;
+    pluralName?: string;
+    description?: string;
+    category?: string;
+    fields: FieldSchemaForGen[];
+    config: CodegenModelConfig;
+    hooks?: Record<string, unknown>;
+}
+export declare function fetchModelsForCodegen(client: GraphQLClient): Promise<CodegenModel[]>;
+/**
+ * Filter models based on pull config options.
+ */
+export declare function filterModels(models: CodegenModel[], options: {
+    only?: string[];
+    includeInline?: boolean;
+}): CodegenModel[];
+//# sourceMappingURL=fetch-models.d.ts.map

package/dist/codegen/fetch-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-models.d.ts","sourceRoot":"","sources":["../../src/codegen/fetch-models.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,KAAK,CAAC;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC;CAC1F;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAgCD,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC,CAezB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,YAAY,EAAE,EACtB,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,GACpD,YAAY,EAAE,CAahB"}

package/dist/codegen/fetch-models.js

@@ -0,0 +1,45 @@
+/**
+ * Fetches models from the platform GraphQL API and transforms them for codegen.
+ */
+import { MODELS_FOR_CODEGEN } from '../graphql/queries.js';
+function normalizeConfig(raw) {
+    return {
+        records: Boolean(raw.records ?? true),
+        inline: Boolean(raw.inline ?? false),
+        publicApi: Boolean(raw.publicApi ?? false),
+        versioning: Boolean(raw.versioning ?? false),
+        publishing: Boolean(raw.publishing ?? false),
+        variants: Boolean(raw.variants ?? false),
+        customerScoped: Boolean(raw.customerScoped ?? false),
+        embeddings: raw.embeddings,
+    };
+}
+export async function fetchModelsForCodegen(client) {
+    const data = await client.request(MODELS_FOR_CODEGEN, {
+        limit: 500,
+    });
+    return data.models.items.map((item) => ({
+        key: item.key,
+        name: item.name,
+        pluralName: item.pluralName,
+        description: item.description,
+        category: item.category,
+        fields: item.fields ?? [],
+        config: normalizeConfig(item.config ?? {}),
+        hooks: item.hooks,
+    }));
+}
+/**
+ * Filter models based on pull config options.
+ */
+export function filterModels(models, options) {
+    let filtered = models;
+    if (options.only && options.only.length > 0) {
+        const onlySet = new Set(options.only);
+        filtered = filtered.filter((m) => onlySet.has(m.key));
+    }
+    if (!options.includeInline) {
+        filtered = filtered.filter((m) => m.config.records);
+    }
+    return filtered;
+}

package/dist/codegen/field-mapping.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Maps EIDE field types to TypeScript types.
+ * Ported from uniformgen with updates for the unified data layer.
+ */
+export interface TypeMapping {
+    outputType: string;
+    inputType: string;
+    needsImport?: string;
+}
+export declare const PRIMITIVE_FIELD_TYPES: Set<string>;
+export declare function isPrimitiveFieldType(type: string): boolean;
+export declare const FIELD_TYPE_MAPPING: Record<string, TypeMapping>;
+export interface FieldSchemaForGen {
+    key: string;
+    type: string;
+    label?: string;
+    required?: boolean;
+    helpText?: string;
+    options?: Record<string, unknown>;
+}
+export declare function getFieldType(field: FieldSchemaForGen, mode?: 'output' | 'input'): string;
+export declare function getRequiredImports(fields: FieldSchemaForGen[]): Set<string>;
+export declare function getInlineSchemaReferences(fields: FieldSchemaForGen[]): Set<string>;
+export declare function toCamelCase(str: string): string;
+export declare function toPascalCase(str: string): string;
+export declare function sanitizeFieldName(key: string): string;
+export declare function generateFieldDef(field: FieldSchemaForGen): string;
+//# sourceMappingURL=field-mapping.d.ts.map

package/dist/codegen/field-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-mapping.d.ts","sourceRoot":"","sources":["../../src/codegen/field-mapping.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,qBAAqB,aAsBhC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAsB1D,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,iBAAiB,EACxB,IAAI,GAAE,QAAQ,GAAG,OAAkB,GAClC,MAAM,CAqCR;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAW3E;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAclF;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG/C;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAyDjE"}

package/dist/codegen/field-mapping.js

@@ -0,0 +1,194 @@
+/**
+ * Maps EIDE field types to TypeScript types.
+ * Ported from uniformgen with updates for the unified data layer.
+ */
+export const PRIMITIVE_FIELD_TYPES = new Set([
+    'text',
+    'richtext',
+    'number',
+    'boolean',
+    'email',
+    'phone',
+    'url',
+    'date',
+    'image',
+    'video',
+    'file',
+    'currency',
+    'select',
+    'multiselect',
+    'json',
+    'list',
+    'tree',
+    'entity-reference',
+    'reference',
+    'link',
+    'flexible',
+]);
+export function isPrimitiveFieldType(type) {
+    return PRIMITIVE_FIELD_TYPES.has(type);
+}
+export const FIELD_TYPE_MAPPING = {
+    text: { outputType: 'string', inputType: 'string' },
+    richtext: { outputType: 'RichtextValue', inputType: 'RichtextValue', needsImport: 'field-types' },
+    number: { outputType: 'number', inputType: 'number' },
+    boolean: { outputType: 'boolean', inputType: 'boolean' },
+    email: { outputType: 'string', inputType: 'string' },
+    phone: { outputType: 'string', inputType: 'string' },
+    url: { outputType: 'string', inputType: 'string' },
+    date: { outputType: 'Date', inputType: 'string' },
+    image: { outputType: 'ImageValue', inputType: 'string', needsImport: 'field-types' },
+    video: { outputType: 'VideoValue', inputType: 'string', needsImport: 'field-types' },
+    file: { outputType: 'FileValue', inputType: 'string', needsImport: 'field-types' },
+    currency: { outputType: 'CurrencyValue', inputType: 'CurrencyValue', needsImport: 'field-types' },
+    select: { outputType: 'string', inputType: 'string' },
+    multiselect: { outputType: 'string[]', inputType: 'string[]' },
+    json: { outputType: 'unknown', inputType: 'unknown' },
+    list: { outputType: 'unknown[]', inputType: 'unknown[]' },
+    tree: { outputType: 'unknown[]', inputType: 'unknown[]' },
+    flexible: { outputType: 'FlexibleFieldItem[]', inputType: 'FlexibleFieldItem[]', needsImport: 'field-types' },
+    'entity-reference': { outputType: 'ReferenceValue', inputType: 'ReferenceValue', needsImport: 'field-types' },
+    reference: { outputType: 'ReferenceValue', inputType: 'ReferenceValue', needsImport: 'field-types' },
+    link: { outputType: 'LinkValue', inputType: 'LinkValue', needsImport: 'field-types' },
+};
+export function getFieldType(field, mode = 'output') {
+    if (!field?.type)
+        return 'unknown';
+    const mapping = FIELD_TYPE_MAPPING[field.type];
+    if (!mapping) {
+        if (isPrimitiveFieldType(field.type))
+            return 'unknown';
+        return toPascalCase(field.type);
+    }
+    let tsType = mode === 'output' ? mapping.outputType : mapping.inputType;
+    if (field.type === 'select' && field.options?.options) {
+        const options = field.options.options;
+        if (options.length > 0) {
+            tsType = options.map((o) => `'${o.value}'`).join(' | ');
+        }
+    }
+    if (field.type === 'multiselect' && field.options?.options) {
+        const options = field.options.options;
+        if (options.length > 0) {
+            tsType = `(${options.map((o) => `'${o.value}'`).join(' | ')})[]`;
+        }
+    }
+    if ((field.type === 'list' || field.type === 'tree') && field.options?.itemType) {
+        const itemType = field.options.itemType;
+        const itemMapping = FIELD_TYPE_MAPPING[itemType];
+        if (itemMapping) {
+            tsType = `${mode === 'output' ? itemMapping.outputType : itemMapping.inputType}[]`;
+        }
+        else if (!isPrimitiveFieldType(itemType)) {
+            tsType = `${toPascalCase(itemType)}[]`;
+        }
+    }
+    return tsType;
+}
+export function getRequiredImports(fields) {
+    const imports = new Set();
+    for (const field of fields) {
+        const mapping = FIELD_TYPE_MAPPING[field.type];
+        if (mapping?.needsImport)
+            imports.add(mapping.needsImport);
+        if ((field.type === 'list' || field.type === 'tree') && field.options?.itemType) {
+            const itemMapping = FIELD_TYPE_MAPPING[field.options.itemType];
+            if (itemMapping?.needsImport)
+                imports.add(itemMapping.needsImport);
+        }
+    }
+    return imports;
+}
+export function getInlineSchemaReferences(fields) {
+    const refs = new Set();
+    for (const field of fields) {
+        if (!isPrimitiveFieldType(field.type) && !FIELD_TYPE_MAPPING[field.type]) {
+            refs.add(field.type);
+        }
+        if ((field.type === 'list' || field.type === 'tree') && field.options?.itemType) {
+            const itemType = field.options.itemType;
+            if (!isPrimitiveFieldType(itemType) && !FIELD_TYPE_MAPPING[itemType]) {
+                refs.add(itemType);
+            }
+        }
+    }
+    return refs;
+}
+export function toCamelCase(str) {
+    if (!str)
+        return 'unknown';
+    return str.replace(/[-_]([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+export function toPascalCase(str) {
+    if (!str)
+        return 'Unknown';
+    const camel = toCamelCase(str);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+export function sanitizeFieldName(key) {
+    if (!key)
+        return 'unknown';
+    const camel = toCamelCase(key);
+    if (/^[0-9]/.test(camel))
+        return `_${camel}`;
+    return camel;
+}
+export function generateFieldDef(field) {
+    const parts = [];
+    parts.push(`key: '${field.key ?? 'unknown'}'`);
+    parts.push(`type: '${field.type ?? 'text'}'`);
+    parts.push(`label: '${(field.label ?? field.key ?? 'Unknown').replace(/'/g, "\\'")}'`);
+    if (field.required)
+        parts.push('required: true');
+    if (field.helpText)
+        parts.push(`helpText: '${field.helpText.replace(/'/g, "\\'")}'`);
+    if (field.type === 'text' && field.options) {
+        if (field.options.maxLength)
+            parts.push(`maxLength: ${field.options.maxLength}`);
+        if (field.options.minLength)
+            parts.push(`minLength: ${field.options.minLength}`);
+    }
+    if (field.type === 'number' && field.options) {
+        if (field.options.min !== undefined)
+            parts.push(`min: ${field.options.min}`);
+        if (field.options.max !== undefined)
+            parts.push(`max: ${field.options.max}`);
+        if (field.options.step !== undefined)
+            parts.push(`step: ${field.options.step}`);
+    }
+    if ((field.type === 'select' || field.type === 'multiselect') && field.options?.options) {
+        const options = field.options.options;
+        const optionsStr = options
+            .filter((o) => o.value !== undefined)
+            .map((o) => {
+            const label = (o.label ?? o.value ?? '').replace(/'/g, "\\'");
+            const value = (o.value ?? '').replace(/'/g, "\\'");
+            return `{ label: '${label}', value: '${value}' }`;
+        })
+            .join(', ');
+        parts.push(`options: [${optionsStr}]`);
+    }
+    if ((field.type === 'entity-reference' || field.type === 'reference') && field.options?.referenceTypes) {
+        const refTypes = field.options.referenceTypes;
+        parts.push(`referenceTypes: [${refTypes.map((t) => `'${t}'`).join(', ')}]`);
+        if (field.options.multiple)
+            parts.push('multiple: true');
+    }
+    if ((field.type === 'list' || field.type === 'tree') && field.options?.itemType) {
+        parts.push(`itemType: '${field.options.itemType}'`);
+        if (field.options.minItems !== undefined)
+            parts.push(`minItems: ${field.options.minItems}`);
+        if (field.options.maxItems !== undefined)
+            parts.push(`maxItems: ${field.options.maxItems}`);
+    }
+    if ((field.type === 'image' || field.type === 'video' || field.type === 'file') &&
+        field.options) {
+        if (field.options.allowedTypes) {
+            const types = field.options.allowedTypes;
+            parts.push(`allowedTypes: [${types.map((t) => `'${t}'`).join(', ')}]`);
+        }
+        if (field.options.maxSize)
+            parts.push(`maxSize: ${field.options.maxSize}`);
+    }
+    return `{ ${parts.join(', ')} }`;
+}

package/dist/codegen/generators/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates the static config.ts file with ModelConfig type and defineModel() helper.
+ */
+export declare function generateConfigFile(): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/codegen/generators/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/codegen/generators/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,kBAAkB,IAAI,MAAM,CA8E3C"}

package/dist/codegen/generators/config.js

@@ -0,0 +1,82 @@
+/**
+ * Generates the static config.ts file with ModelConfig type and defineModel() helper.
+ */
+export function generateConfigFile() {
+    return `/**
+ * Model Configuration Type
+ *
+ * Strongly-typed model definitions for the unified data layer.
+ *
+ * @generated by foir — DO NOT EDIT MANUALLY
+ */
+
+import type { FieldDef } from './field-types.js';
+
+/**
+ * Model configuration
+ *
+ * Defines the complete configuration for a model including
+ * its schema, capabilities, and lifecycle hooks.
+ *
+ * @example
+ * export const blogPostConfig = {
+ *   key: 'blog-post',
+ *   name: 'Blog Post',
+ *   records: true,
+ *   inline: false,
+ *   publicApi: true,
+ *   versioning: true,
+ *   publishing: true,
+ *   variants: false,
+ *   customerScoped: false,
+ *   fieldDefs: [
+ *     { key: 'title', type: 'text', label: 'Title', required: true },
+ *     { key: 'content', type: 'richtext', label: 'Content' },
+ *   ],
+ * } as const satisfies ModelConfig;
+ */
+export interface ModelConfig {
+  /** Unique identifier (kebab-case) */
+  key: string;
+  /** Display name */
+  name: string;
+  /** Description */
+  description?: string;
+
+  // Capability flags (from model config)
+  /** Can create standalone records */
+  records: boolean;
+  /** Available as inline field type in other models */
+  inline: boolean;
+  /** Exposed via public GraphQL API */
+  publicApi: boolean;
+  /** Version history enabled */
+  versioning: boolean;
+  /** Publishing workflow enabled */
+  publishing: boolean;
+  /** Market/device/locale variants enabled */
+  variants: boolean;
+  /** Customer-level record isolation */
+  customerScoped: boolean;
+
+  /** Embedding configuration */
+  embeddings?: {
+    enabled: boolean;
+    fields: Array<{ fieldPath: string; weight?: number }>;
+  };
+
+  /** Lifecycle hooks configuration */
+  hooks?: Record<string, unknown>;
+
+  /** Field definitions */
+  fieldDefs: readonly FieldDef[];
+}
+
+/**
+ * Helper to create a type-safe model config
+ */
+export function defineModel<T extends ModelConfig>(config: T): T {
+  return config;
+}
+`;
+}

package/dist/codegen/generators/documents.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates per-model .graphql files with CRUD operations for the public API.
+ */
+import type { CodegenModel } from '../fetch-models.js';
+export declare function generateModelDocuments(model: CodegenModel): string;
+//# sourceMappingURL=documents.d.ts.map

package/dist/codegen/generators/documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../src/codegen/generators/documents.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAuFlE"}

package/dist/codegen/generators/documents.js

@@ -0,0 +1,91 @@
+/**
+ * Generates per-model .graphql files with CRUD operations for the public API.
+ */
+import { toPascalCase } from '../field-mapping.js';
+export function generateModelDocuments(model) {
+    const typeName = toPascalCase(model.key);
+    const pluralName = model.pluralName
+        ? toPascalCase(model.pluralName.replace(/\s+/g, ''))
+        : `${typeName}s`;
+    const displayName = model.name ?? model.key;
+    return `# Generated GraphQL operations for ${displayName}
+# @generated by foir — DO NOT EDIT MANUALLY
+
+fragment ${typeName}Fields on Record {
+  id
+  modelKey
+  naturalKey
+  data
+  metadata
+  versionNumber
+  publishedVersionNumber
+  publishStatus
+  createdAt
+  updatedAt
+}
+
+query Get${typeName}($id: ID, $naturalKey: String, $preview: Boolean) {
+  record(modelKey: "${model.key}", id: $id, naturalKey: $naturalKey, preview: $preview) {
+    ...${typeName}Fields
+    resolved {
+      record { id modelKey naturalKey }
+      content { fields { key type label value } }
+    }
+  }
+}
+
+query List${pluralName}(
+  $limit: Int
+  $offset: Int
+  $filters: [FilterInput!]
+  $sort: SortInput
+  $preview: Boolean
+) {
+  records(
+    modelKey: "${model.key}"
+    limit: $limit
+    offset: $offset
+    filters: $filters
+    sort: $sort
+    preview: $preview
+  ) {
+    items {
+      ...${typeName}Fields
+    }
+    total
+    hasMore
+  }
+}
+
+mutation Create${typeName}($data: JSON!) {
+  createRecord(modelKey: "${model.key}", data: $data) {
+    ...${typeName}Fields
+  }
+}
+
+mutation Update${typeName}($id: ID!, $data: JSON!) {
+  updateRecord(modelKey: "${model.key}", id: $id, data: $data) {
+    ...${typeName}Fields
+  }
+}
+
+mutation Delete${typeName}($id: ID!) {
+  deleteRecord(modelKey: "${model.key}", id: $id) {
+    success
+    message
+  }
+}
+
+mutation Publish${typeName}($id: ID!, $versionId: ID) {
+  publishVersion(modelKey: "${model.key}", id: $id, versionId: $versionId) {
+    ...${typeName}Fields
+  }
+}
+
+mutation Unpublish${typeName}($id: ID!) {
+  unpublishRecord(modelKey: "${model.key}", id: $id) {
+    ...${typeName}Fields
+  }
+}
+`;
+}

package/dist/codegen/generators/field-types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates the static field-types.ts file with value types, filter types, and field defs.
+ */
+export declare function generateFieldTypesFile(): string;
+//# sourceMappingURL=field-types.d.ts.map

package/dist/codegen/generators/field-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-types.d.ts","sourceRoot":"","sources":["../../../src/codegen/generators/field-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,sBAAsB,IAAI,MAAM,CA+U/C"}