db4ai 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import type { ComponentType } from 'react';
-export { SerializedFunction, serializeFunction, type EntityHandlerType, type SchemaHandlerType, type LifecycleHandlerType, type StateHandlerType, type HandlerExecutionResult, type HandlerLogEntry, } from './handlers';
-import { type SerializedFunction } from './handlers';
+import { ComponentType } from 'react';
+import { SerializedFunction } from './handlers.js';
+export { EntityHandlerType, HandlerExecutionResult, HandlerLogEntry, LifecycleHandlerType, SchemaHandlerType, StateHandlerType, serializeFunction } from './handlers.js';
+
 /**
  * Error codes for schema validation errors.
  */
-export type SchemaValidationErrorCode = 'MISSING_CONTEXT' | 'MISSING_NAMESPACE' | 'INVALID_FIELD_TYPE';
+type SchemaValidationErrorCode = 'MISSING_CONTEXT' | 'MISSING_NAMESPACE' | 'INVALID_FIELD_TYPE';
 /**
  * Error thrown when schema validation fails.
  *
@@ -17,14 +18,14 @@ export type SchemaValidationErrorCode = 'MISSING_CONTEXT' | 'MISSING_NAMESPACE'
  *   }
  * }
  */
-export declare class SchemaValidationError extends Error {
+declare class SchemaValidationError extends Error {
     code: SchemaValidationErrorCode;
     constructor(code: SchemaValidationErrorCode, message: string);
 }
 /**
  * Error codes for API errors.
  */
-export type APIErrorCode = 'REGISTRATION_FAILED' | 'GENERATION_FAILED' | 'REFERENCE_RESOLUTION_FAILED';
+type APIErrorCode = 'REGISTRATION_FAILED' | 'GENERATION_FAILED' | 'REFERENCE_RESOLUTION_FAILED';
 /**
  * Error thrown when API operations fail.
  *
@@ -38,12 +39,12 @@ export type APIErrorCode = 'REGISTRATION_FAILED' | 'GENERATION_FAILED' | 'REFERE
  *   }
  * }
  */
-export declare class APIError extends Error {
+declare class APIError extends Error {
     code: APIErrorCode;
     statusCode?: number;
     constructor(code: APIErrorCode, message: string, statusCode?: number);
 }
-export type Components = {
+type Components = {
     App: ComponentType;
     List: ComponentType;
     ListItem: ComponentType;
@@ -51,7 +52,7 @@ export type Components = {
     Edit: ComponentType;
     Chat: ComponentType;
 };
-export declare function UI(components: Components): Components;
+declare function UI(components: Components): Components;
 /**
  * Parse namespace from a $id URL.
  *
@@ -64,15 +65,15 @@ export declare function UI(components: Components): Components;
  * parseNamespaceFromId('https://db.sb/') // null
  * parseNamespaceFromId('invalid') // null
  */
-export declare function parseNamespaceFromId(id: string): string | null;
+declare function parseNamespaceFromId(id: string): string | null;
 /**
  * Computed field - a function that derives a value from the entity.
  */
-export type ComputedFieldFn<E = any, R = any> = (entity: E, $?: any) => R;
+type ComputedFieldFn<E = any, R = any> = (entity: E, $?: any) => R;
 /**
  * Nested object field value - used for complex structures like StoryBrand.hero.wants
  */
-export interface NestedFieldValue {
+interface NestedFieldValue {
     [key: string]: string | string[] | boolean | NestedFieldValue | ComputedFieldFn;
 }
 /**
@@ -83,43 +84,43 @@ export interface NestedFieldValue {
  * - `boolean` - Relationship marker (e.g., '->Entity[]': true)
  * - `Function` - Computed field
  */
-export type FieldValue = string | string[] | boolean | NestedFieldValue | ComputedFieldFn;
+type FieldValue = string | string[] | boolean | NestedFieldValue | ComputedFieldFn;
 /**
  * Entity lifecycle handler.
  */
-export type EntityHandler<E = any> = (entity: E, $: any) => void | Promise<void>;
+type EntityHandler<E = any> = (entity: E, $: any) => void | Promise<void>;
 /**
  * Entity update handler with previous state.
  */
-export type EntityUpdateHandler<E = any> = (entity: E, previous: E, $: any) => void | Promise<void>;
+type EntityUpdateHandler<E = any> = (entity: E, previous: E, $: any) => void | Promise<void>;
 /**
  * Schema lifecycle handler.
  */
-export type SchemaHandler = ($: any) => void | Promise<void>;
+type SchemaHandler = ($: any) => void | Promise<void>;
 /**
  * Schema error handler.
  */
-export type SchemaErrorHandler = (error: Error, $: any) => void | Promise<void>;
+type SchemaErrorHandler = (error: Error, $: any) => void | Promise<void>;
 /**
  * Input state machine configuration for entity definitions.
  * This is the raw format before parsing - use RawStateConfig from state machine types.
  */
-export type InputStateConfig = {
+type InputStateConfig = {
     $initial: string;
 } & Record<string, unknown>;
 /**
  * Evaluation definition stub.
  */
-export type EvalDefinition = Record<string, unknown>;
+type EvalDefinition = Record<string, unknown>;
 /**
  * Schema experiment definition stub.
  */
-export type SchemaExperiment = Record<string, unknown>;
+type SchemaExperiment = Record<string, unknown>;
 /**
  * Schema analytics configuration stub.
  */
-export type SchemaAnalytics = Record<string, unknown>;
-export interface SchemaMetadata {
+type SchemaAnalytics = Record<string, unknown>;
+interface SchemaMetadata {
     /** Unique identifier/URL for this schema */
     $id?: string;
     /** Shared namespace for composing multiple DB() schemas */
@@ -146,7 +147,7 @@ export interface SchemaMetadata {
 /**
  * Entity-level directives that can appear in type definitions.
  */
-export interface EntityDirectives {
+interface EntityDirectives {
     /** Seed data source URL */
     $seed?: string;
     /** JSONPath or transform for entity ID from seed data (e.g., '$.slug', 'PascalCase($.name)') */
@@ -178,13 +179,13 @@ export interface EntityDirectives {
  * Type definition: entity directives + field definitions.
  * Allows any string key for fields and relationship markers.
  */
-export type TypeDefinition = EntityDirectives & Record<string, FieldValue | undefined>;
+type TypeDefinition = EntityDirectives & Record<string, FieldValue | undefined>;
 /**
  * Schema: metadata + type definitions.
  * Allows entity type definitions with all directives and field types.
  */
-export type SchemaDefinition = SchemaMetadata & Record<string, TypeDefinition | string | undefined>;
-export interface StringField {
+type SchemaDefinition = SchemaMetadata & Record<string, TypeDefinition | string | undefined>;
+interface StringField {
     type: 'string';
     description: string;
     optional?: boolean;
@@ -206,7 +207,7 @@ export interface StringField {
  * { posts: '<-Post' }      // Find Posts that reference this entity
  * { related: '<~Article' } // Find semantically related Articles
  */
-export declare const OPERATORS: {
+declare const OPERATORS: {
     /** Forward exact reference: `->Type` - resolves to exact ID match */
     readonly FORWARD_EXACT: "->";
     /** Forward fuzzy reference: `~>Type` - resolves by semantic similarity */
@@ -217,9 +218,9 @@ export declare const OPERATORS: {
     readonly BACKWARD_FUZZY: "<~";
 };
 /** Type for all valid reference operators */
-export type ReferenceOperator = (typeof OPERATORS)[keyof typeof OPERATORS];
+type ReferenceOperator = (typeof OPERATORS)[keyof typeof OPERATORS];
 /** Parsed operator information returned by parseOperator */
-export type ParsedOperator = {
+type ParsedOperator = {
     direction: 'forward';
     fuzzy: boolean;
 } | {
@@ -241,7 +242,7 @@ export type ParsedOperator = {
  * parseOperator('<-') // { direction: 'backward', mode: 'exact' }
  * parseOperator('<~') // { direction: 'backward', mode: 'fuzzy' }
  */
-export declare function parseOperator(prefix: string): ParsedOperator;
+declare function parseOperator(prefix: string): ParsedOperator;
 /**
  * Parsed reference field from the schema DSL.
  *
@@ -266,7 +267,7 @@ export declare function parseOperator(prefix: string): ParsedOperator;
  * parseFieldType('<~Post[]')
  * // { type: 'reference', ref: 'Post', isArray: true, optional: false, direction: 'backward', mode: 'fuzzy' }
  */
-export interface ReferenceField {
+interface ReferenceField {
     type: 'reference';
     /** Single reference target type (mutually exclusive with `refs`) */
     ref?: string;
@@ -283,7 +284,7 @@ export interface ReferenceField {
     /** For backward references: 'exact' (`<-`) or 'fuzzy' (`<~`) */
     mode?: 'exact' | 'fuzzy';
 }
-export interface ArrayField {
+interface ArrayField {
     type: 'array';
     items: {
         type: 'string';
@@ -297,39 +298,39 @@ export interface ArrayField {
         max: number;
     };
 }
-export interface ObjectField {
+interface ObjectField {
     type: 'object';
     properties: Record<string, StringField>;
     optional?: boolean;
 }
-export interface EmbeddedField {
+interface EmbeddedField {
     type: 'embedded';
     embeddedType: string;
     isArray?: boolean;
     optional?: boolean;
 }
-export interface JSONPathField {
+interface JSONPathField {
     type: 'jsonpath';
     path: string;
     transform?: string;
 }
-export interface JSONPathEmbeddedField {
+interface JSONPathEmbeddedField {
     type: 'jsonpath-embedded';
     path: string;
     embeddedType: string;
     isArray: boolean;
     optional?: boolean;
 }
-export interface ComputedField {
+interface ComputedField {
     type: 'computed';
     source: string;
 }
-export interface PromptField {
+interface PromptField {
     type: 'prompt';
     prompt: string;
 }
-export type ParsedField = StringField | ReferenceField | ArrayField | ObjectField | EmbeddedField | JSONPathField | JSONPathEmbeddedField | ComputedField | PromptField;
-export interface TypeReference {
+type ParsedField = StringField | ReferenceField | ArrayField | ObjectField | EmbeddedField | JSONPathField | JSONPathEmbeddedField | ComputedField | PromptField;
+interface TypeReference {
     field: string;
     ref: string;
     refs?: string[];
@@ -338,7 +339,7 @@ export interface TypeReference {
     fuzzy?: boolean;
     backRef?: boolean;
 }
-export interface SeedConfig {
+interface SeedConfig {
     url: string;
     format?: 'tsv' | 'csv' | 'json';
     idField?: string;
@@ -359,7 +360,7 @@ export interface SeedConfig {
  * parseIdConfig('kebab-case($.title)')       // { path: '$.title', transform: 'kebab-case' }
  * parseIdConfig('slug')                      // { path: 'slug' }
  */
-export declare function parseIdConfig(idField: string): {
+declare function parseIdConfig(idField: string): {
     path: string;
     transform?: string;
 };
@@ -384,7 +385,7 @@ export declare function parseIdConfig(idField: string): {
  * isValidJSONPath('title')             // false (missing $.)
  * isValidJSONPath('$50 price')         // false (not a valid path)
  */
-export declare function isValidJSONPath(path: string): boolean;
+declare function isValidJSONPath(path: string): boolean;
 /**
  * Type guard to check if a ParsedField is a JSONPathField.
  *
@@ -394,7 +395,7 @@ export declare function isValidJSONPath(path: string): boolean;
  *   console.log(field.path)  // TypeScript knows field.path exists
  * }
  */
-export declare function isJSONPathField(field: ParsedField): field is JSONPathField;
+declare function isJSONPathField(field: ParsedField): field is JSONPathField;
 /**
  * Type guard to check if a ParsedField is a JSONPathEmbeddedField.
  *
@@ -404,7 +405,7 @@ export declare function isJSONPathField(field: ParsedField): field is JSONPathFi
  *   console.log(field.embeddedType)  // TypeScript knows field.embeddedType exists
  * }
  */
-export declare function isJSONPathEmbeddedField(field: ParsedField): field is JSONPathEmbeddedField;
+declare function isJSONPathEmbeddedField(field: ParsedField): field is JSONPathEmbeddedField;
 /**
  * Type guard to check if a ParsedField is a PromptField.
  *
@@ -414,21 +415,21 @@ export declare function isJSONPathEmbeddedField(field: ParsedField): field is JS
  *   console.log(field.prompt)  // TypeScript knows field.prompt exists
  * }
  */
-export declare function isPromptField(field: ParsedField): field is PromptField;
+declare function isPromptField(field: ParsedField): field is PromptField;
 /**
  * Type guard to check if a ParsedField is a StringField.
  */
-export declare function isStringField(field: ParsedField): field is StringField;
-export interface OAuthConfig {
+declare function isStringField(field: ParsedField): field is StringField;
+interface OAuthConfig {
     tokenUrl: string;
     clientId: string;
     clientSecret: string;
 }
-export interface AsyncConfig {
+interface AsyncConfig {
     start: string;
     result: string;
 }
-export interface SourceConfig {
+interface SourceConfig {
     $api: string;
     $apiKey?: string;
     $bearer?: string;
@@ -436,54 +437,54 @@ export interface SourceConfig {
     $data?: string;
     $async?: AsyncConfig;
 }
-export type SourceInput = Record<string, 'string' | 'string?'>;
-export interface ImageConfig {
+type SourceInput = Record<string, 'string' | 'string?'>;
+interface ImageConfig {
     aspectRatio?: string;
     style?: string;
 }
-export interface SpeechConfig {
+interface SpeechConfig {
     voice?: string;
     speed?: number;
     format?: string;
 }
-export interface DiagramConfig {
+interface DiagramConfig {
     type?: string;
     direction?: string;
     format?: string;
 }
-export interface ConventionsConfig {
+interface ConventionsConfig {
     nodes?: string;
     edges?: string;
     events?: string;
 }
-export interface CodeConfig {
+interface CodeConfig {
     language?: string;
     runtime?: string;
     framework?: string;
 }
 /** Transition configuration - simple string or complex object */
-export interface TransitionConfig {
+interface TransitionConfig {
     to: string | null;
     if?: SerializedFunction;
     do?: SerializedFunction;
 }
 /** State configuration with transitions */
-export interface StateConfig {
+interface StateConfig {
     transitions: Record<string, TransitionConfig>;
     $entry?: SerializedFunction;
     $exit?: SerializedFunction;
 }
 /** Parsed state machine configuration */
-export interface ParsedStateConfig {
+interface ParsedStateConfig {
     $initial: string;
     states: Record<string, StateConfig>;
 }
 /** Raw state config - input format before parsing */
-export type RawStateConfig = {
+type RawStateConfig = {
     $initial: string;
 } & Record<string, unknown>;
 /** State validation error */
-export interface StateValidationError {
+interface StateValidationError {
     code: string;
     message: string;
     state?: string;
@@ -491,7 +492,7 @@ export interface StateValidationError {
     transition?: string;
 }
 /** State validation result */
-export interface StateValidationResult {
+interface StateValidationResult {
     valid: boolean;
     errors: StateValidationError[];
 }
@@ -499,7 +500,7 @@ export interface StateValidationResult {
  * Validate a raw state machine configuration.
  * Checks for: valid $initial, reachable states, no orphan states, valid transitions.
  */
-export declare function validateStateConfig(config: RawStateConfig): StateValidationResult;
+declare function validateStateConfig(config: RawStateConfig): StateValidationResult;
 /**
  * Parse a raw state machine configuration into the normalized format.
  * Converts string functions to SerializedFunction objects.
@@ -520,8 +521,8 @@ export declare function validateStateConfig(config: RawStateConfig): StateValida
  *   approved: null  // terminal state
  * })
  */
-export declare function parseStateConfig(config: RawStateConfig): ParsedStateConfig;
-export interface ParsedType {
+declare function parseStateConfig(config: RawStateConfig): ParsedStateConfig;
+interface ParsedType {
     name: string;
     fields: Record<string, ParsedField>;
     references: TypeReference[];
@@ -547,10 +548,10 @@ export interface ParsedType {
     eval?: Record<string, EvalDefinition>;
     experiment?: SchemaExperiment;
 }
-export interface SchemaSettings {
+interface SchemaSettings {
     iconLibrary?: string;
 }
-export interface ParsedSchema {
+interface ParsedSchema {
     types: Record<string, ParsedType>;
     hash: string;
     settings?: SchemaSettings;
@@ -561,7 +562,7 @@ export interface ParsedSchema {
     analytics?: SchemaAnalytics;
     handlers?: Record<string, SerializedFunction>;
 }
-export interface JSONSchemaProperty {
+interface JSONSchemaProperty {
     type: string;
     description?: string;
     items?: {
@@ -576,13 +577,13 @@ export interface JSONSchemaProperty {
     minItems?: number;
     maxItems?: number;
 }
-export interface JSONSchema {
+interface JSONSchema {
     type: 'object';
     properties: Record<string, JSONSchemaProperty>;
     required: string[];
     additionalProperties: boolean;
 }
-export declare function extractCountFromDescription(description: string): number | {
+declare function extractCountFromDescription(description: string): number | {
     min: number;
     max: number;
 } | undefined;
@@ -663,12 +664,12 @@ export declare function extractCountFromDescription(description: string): number
  * parseFieldType({ street: 'Street address', city: 'City name' })
  * // { type: 'object', properties: { street: {...}, city: {...} } }
  */
-export declare function parseFieldType(value: FieldValue | Function): ParsedField;
+declare function parseFieldType(value: FieldValue | Function): ParsedField;
 /**
  * Parsed reference field info for generation.
  * Used by the two-phase generation pipeline to understand reference fields.
  */
-export interface ParsedGenerationReference {
+interface ParsedGenerationReference {
     /** Reference mode: exact (->) or fuzzy (~>) */
     mode: 'exact' | 'fuzzy';
     /** Target type name (or first type for union types) */
@@ -705,7 +706,7 @@ export interface ParsedGenerationReference {
  * parseGenerationReference('->User|Organization')
  * // { mode: 'exact', targetType: 'User', targetTypes: ['User', 'Organization'], isOptional: false, isArray: false }
  */
-export declare function parseGenerationReference(fieldDef: string): ParsedGenerationReference | null;
+declare function parseGenerationReference(fieldDef: string): ParsedGenerationReference | null;
 /**
  * Parse array field definition for generation.
  *
@@ -718,7 +719,7 @@ export declare function parseGenerationReference(fieldDef: string): ParsedGenera
  * parseGenerationArrayReference(['~>Investor'])
  * // { mode: 'fuzzy', targetType: 'Investor', isOptional: false, isArray: true }
  */
-export declare function parseGenerationArrayReference(fieldDef: string[]): ParsedGenerationReference | null;
+declare function parseGenerationArrayReference(fieldDef: string[]): ParsedGenerationReference | null;
 /**
  * Check if a field definition is a reference field.
  *
@@ -732,21 +733,21 @@ export declare function parseGenerationArrayReference(fieldDef: string[]): Parse
  * isReferenceField('User name')  // false
  * isReferenceField(['tags'])  // false
  */
-export declare function isReferenceField(fieldDef: string | string[]): boolean;
+declare function isReferenceField(fieldDef: string | string[]): boolean;
 /**
  * Extract reference mode from a field definition.
  *
  * @param fieldDef - The field definition
  * @returns 'exact' | 'fuzzy' | null
  */
-export declare function getReferenceMode(fieldDef: string | string[]): 'exact' | 'fuzzy' | null;
+declare function getReferenceMode(fieldDef: string | string[]): 'exact' | 'fuzzy' | null;
 /**
  * Extract target type(s) from a reference field.
  *
  * @param fieldDef - The field definition
  * @returns Target type string, array of types for unions, or null if not a reference
  */
-export declare function getReferenceTargetType(fieldDef: string | string[]): string | string[] | null;
+declare function getReferenceTargetType(fieldDef: string | string[]): string | string[] | null;
 /**
  * Parse seed configuration from a schema type's `$seed` field.
  *
@@ -784,7 +785,7 @@ export declare function getReferenceTargetType(fieldDef: string | string[]): str
  * })
  * // { url: '...', format: 'json', data: '$.items', next: '$.pagination.next' }
  */
-export declare function parseSeedConfig(value: string | Record<string, string>): SeedConfig;
+declare function parseSeedConfig(value: string | Record<string, string>): SeedConfig;
 /**
  * Converts string fields to prompt fields in a seeded type's field map.
  *
@@ -814,7 +815,7 @@ export declare function parseSeedConfig(value: string | Record<string, string>):
  * This function is called during parseSchema when a type has `$seed` defined.
  * Only StringField types are converted; all other field types pass through unchanged.
  */
-export declare function convertStringsToPromptsInSeededType(fields: Record<string, ParsedField>): Record<string, ParsedField>;
+declare function convertStringsToPromptsInSeededType(fields: Record<string, ParsedField>): Record<string, ParsedField>;
 /**
  * Parse an entire schema definition into a structured ParsedSchema.
  *
@@ -869,7 +870,7 @@ export declare function convertStringsToPromptsInSeededType(fields: Record<strin
  * // schema.types.Company.icon === 'building'
  * // schema.types.Company.seed.url === 'https://api.example.com/companies.json'
  */
-export declare function parseSchema(schema: SchemaDefinition): ParsedSchema;
+declare function parseSchema(schema: SchemaDefinition): ParsedSchema;
 /**
  * Convert a parsed type definition to a JSON Schema representation.
  *
@@ -928,7 +929,7 @@ export declare function parseSchema(schema: SchemaDefinition): ParsedSchema;
  * const jsonSchema = toJSONSchema(schema.types.User, schema)
  * // properties.address will contain the full Address schema inline
  */
-export declare function toJSONSchema(parsedType: ParsedType, parsedSchemaOrIncludeRefs?: ParsedSchema | boolean, seen?: Set<string>): JSONSchema;
+declare function toJSONSchema(parsedType: ParsedType, parsedSchemaOrIncludeRefs?: ParsedSchema | boolean, seen?: Set<string>): JSONSchema;
 /**
  * Generate a deterministic hash for a schema definition.
  *
@@ -961,9 +962,9 @@ export declare function toJSONSchema(parsedType: ParsedType, parsedSchemaOrInclu
  * console.log(schema.hash)
  * // The hash can be used to detect schema changes and trigger migrations
  */
-export declare function schemaHash(schema: SchemaDefinition): string;
-export type JobStatus = 'queued' | 'running' | 'completed' | 'failed';
-export interface Job<T = void> {
+declare function schemaHash(schema: SchemaDefinition): string;
+type JobStatus = 'queued' | 'running' | 'completed' | 'failed';
+interface Job<T = void> {
     id: string;
     status: JobStatus;
     result?: T;
@@ -974,7 +975,16 @@ export interface Job<T = void> {
  * - As factory: `await db.Idea('id', { concept: '...' })`
  * - As collection: `for (const idea of db.Idea) { ... }`
  */
-export interface EntityCollection<T extends Record<string, unknown> = Record<string, unknown>> extends Iterable<T> {
+/** Options for listing entities */
+interface ListOptions {
+    /** Maximum number of entities to return */
+    limit?: number;
+    /** Number of entities to skip */
+    offset?: number;
+    /** Filter criteria */
+    filter?: Record<string, unknown>;
+}
+interface EntityCollection<T extends Record<string, unknown> = Record<string, unknown>> extends Iterable<T> {
     /** The type name of entities in this collection */
     readonly $type: string;
     /** Current count of entities in the local collection */
@@ -987,17 +997,23 @@ export interface EntityCollection<T extends Record<string, unknown> = Record<str
     where(predicate: (item: T) => boolean): Combinable<T>;
     /** Fetch all entities from API and populate collection */
     fetchAll(): Promise<T[]>;
+    /** List entities with optional limit, offset, and filter */
+    list(options?: ListOptions): Promise<T[]>;
+    /** Get a single entity by ID */
+    get(id: string): Promise<T | undefined>;
+    /** Create a new entity with the given data */
+    create(data: Partial<T>): Promise<T>;
     /** Factory function signature - call the collection to generate/fetch an entity */
     (id: string, context?: Record<string, unknown>): Promise<T>;
 }
-export interface DBInstance<T = Record<string, unknown>> {
+interface DBInstance<T = Record<string, unknown>> {
     id: string;
     type: string;
     data: T;
 }
-export type GeneratedObject = Record<string, unknown>;
-export type TypeFactory = (id: string, context?: Record<string, unknown>) => Promise<GeneratedObject>;
-export interface DBResultBase {
+type GeneratedObject = Record<string, unknown>;
+type TypeFactory = (id: string, context?: Record<string, unknown>) => Promise<GeneratedObject>;
+interface DBResultBase {
     schema: SchemaDefinition;
     types: Record<string, ParsedType>;
     hash: string;
@@ -1009,7 +1025,7 @@ export interface DBResultBase {
     toJSONSchema: (typeName: string) => JSONSchema;
     registerSchema: () => Promise<void>;
 }
-export type DBResult = DBResultBase & Record<string, EntityCollection>;
+type DBResult = DBResultBase & Record<string, EntityCollection>;
 /**
  * Create a database instance from a schema definition.
  *
@@ -1080,7 +1096,7 @@ export type DBResult = DBResultBase & Record<string, EntityCollection>;
  *   }
  * })
  */
-export declare function DB(schema: SchemaDefinition): DBResult;
+declare function DB(schema: SchemaDefinition): DBResult;
 /**
  * A lazy pipeline builder for cartesian products and collection transformations.
  *
@@ -1133,7 +1149,7 @@ export declare function DB(schema: SchemaDefinition): DBResult;
  *   .map(user => user.email)
  *   .all()
  */
-export declare class Combinable<T> implements Iterable<T> {
+declare class Combinable<T> implements Iterable<T> {
     private readonly source;
     constructor(source: () => Generator<T>);
     /**
@@ -1169,14 +1185,14 @@ export declare class Combinable<T> implements Iterable<T> {
      */
     [Symbol.iterator](): Iterator<T>;
 }
-export declare function combine<A, B>(a: Iterable<A>, b: Iterable<B>): Combinable<[A, B]>;
-export declare function combine<A, B, C>(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>): Combinable<[A, B, C]>;
-export declare function combine<A, B, C, D>(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>): Combinable<[A, B, C, D]>;
-export declare function combine<A, B, C, D, E>(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>, e: Iterable<E>): Combinable<[A, B, C, D, E]>;
+declare function combine<A, B>(a: Iterable<A>, b: Iterable<B>): Combinable<[A, B]>;
+declare function combine<A, B, C>(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>): Combinable<[A, B, C]>;
+declare function combine<A, B, C, D>(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>): Combinable<[A, B, C, D]>;
+declare function combine<A, B, C, D, E>(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>, e: Iterable<E>): Combinable<[A, B, C, D, E]>;
 /**
  * Result of parsing MDX frontmatter
  */
-export interface ParseMDXResult {
+interface ParseMDXResult {
     /** Parsed schema definition from YAML frontmatter */
     schema: SchemaDefinition;
     /** Remaining MDX body after frontmatter */
@@ -1202,18 +1218,18 @@ export interface ParseMDXResult {
  * // schema = { $context: 'https://db.sb', Idea: { concept: 'What is the concept?' } }
  * // body = '\n<App>content</App>'
  */
-export declare function parseMDX(mdx: string): ParseMDXResult;
+declare function parseMDX(mdx: string): ParseMDXResult;
 /**
  * Hook context passed to entity hooks
  */
-export interface HookContext {
+interface HookContext {
     generate: (types: string | string[]) => Promise<void>;
     changed?: Record<string, boolean>;
 }
 /**
  * Entity lifecycle hooks
  */
-export interface EntityHooks {
+interface EntityHooks {
     onCreate?: (entity: unknown, ctx: HookContext) => Promise<void>;
     onUpdate?: (entity: unknown, ctx: HookContext) => Promise<void>;
     onDelete?: (entity: unknown) => Promise<void>;
@@ -1221,7 +1237,7 @@ export interface EntityHooks {
 /**
  * Navigation group in the sidebar
  */
-export interface NavigationGroup {
+interface NavigationGroup {
     name: string;
     icon?: string;
     children: (NavigationGroup | string)[];
@@ -1229,7 +1245,7 @@ export interface NavigationGroup {
 /**
  * Field configuration from <Field> elements
  */
-export interface FieldConfig {
+interface FieldConfig {
     name: string;
     lines?: number;
     placeholder?: string;
@@ -1248,7 +1264,7 @@ export interface FieldConfig {
 /**
  * Section configuration from <Section> elements
  */
-export interface SectionConfig {
+interface SectionConfig {
     label: string;
     collapsed?: boolean;
     children?: (FieldConfig | SectionConfig)[];
@@ -1256,20 +1272,20 @@ export interface SectionConfig {
 /**
  * Search configuration from <Search> elements
  */
-export interface SearchConfig {
+interface SearchConfig {
     fields?: string[];
 }
 /**
  * Filter configuration from <Filter> elements
  */
-export interface FilterConfig {
+interface FilterConfig {
     field: string;
     exists?: boolean;
 }
 /**
  * Action configuration for generate/built-in actions
  */
-export interface ActionConfig {
+interface ActionConfig {
     type: 'generate' | 'delete' | 'duplicate' | 'export' | 'import';
     entity?: string;
     context?: string[];
@@ -1279,20 +1295,20 @@ export interface ActionConfig {
 /**
  * Role-based permission configuration
  */
-export interface RoleConfig {
+interface RoleConfig {
     name: string;
     actions: string[];
 }
 /**
  * Template configuration for Cards/Detail views
  */
-export interface TemplateConfig {
+interface TemplateConfig {
     jsx: string;
 }
 /**
  * Form configuration from <Form> elements
  */
-export interface FormConfig {
+interface FormConfig {
     layout?: 'stack' | 'grid';
     fields?: string[];
     children?: (FieldConfig | SectionConfig)[];
@@ -1300,7 +1316,7 @@ export interface FormConfig {
 /**
  * Display component configuration
  */
-export interface DisplayConfig {
+interface DisplayConfig {
     type: 'table' | 'grid' | 'cards';
     columns?: string[];
     sortable?: boolean;
@@ -1309,7 +1325,7 @@ export interface DisplayConfig {
 /**
  * View configuration (List, Detail, Edit, Create)
  */
-export interface ViewConfig {
+interface ViewConfig {
     search?: SearchConfig;
     filters?: FilterConfig[];
     display?: DisplayConfig;
@@ -1322,7 +1338,7 @@ export interface ViewConfig {
 /**
  * Collection configuration for a schema type
  */
-export interface CollectionConfig {
+interface CollectionConfig {
     view?: 'table' | 'cards' | 'grid';
     columns?: string[];
     searchable?: boolean;
@@ -1339,7 +1355,7 @@ export interface CollectionConfig {
 /**
  * Complete UI configuration parsed from JSX
  */
-export interface UIConfig {
+interface UIConfig {
     hooks: Record<string, EntityHooks>;
     navigation: NavigationGroup[];
     collections: Record<string, CollectionConfig>;
@@ -1365,11 +1381,11 @@ export interface UIConfig {
  * // config.navigation = [{ name: 'Planning', icon: 'lightbulb', children: ['Idea'] }]
  * // config.collections = { Idea: { view: 'cards' } }
  */
-export declare function parseJSXUI(jsx: string, schema: ParsedSchema): UIConfig;
+declare function parseJSXUI(jsx: string, schema: ParsedSchema): UIConfig;
 /**
  * Result of processing an MDX file
  */
-export interface ProcessMDXResult {
+interface ProcessMDXResult {
     /** Raw YAML schema definition */
     schema: SchemaDefinition;
     /** Parsed schema with types, fields, and references */
@@ -1382,5 +1398,6 @@ export interface ProcessMDXResult {
 /**
  * Process an MDX file and return all parsed components.
  */
-export declare function processMDX(mdx: string): ProcessMDXResult;
-//# sourceMappingURL=index.d.ts.map
+declare function processMDX(mdx: string): ProcessMDXResult;
+
+export { APIError, type APIErrorCode, type ActionConfig, type ArrayField, type AsyncConfig, type CodeConfig, type CollectionConfig, Combinable, type Components, type ComputedField, type ComputedFieldFn, type ConventionsConfig, DB, type DBInstance, type DBResult, type DBResultBase, type DiagramConfig, type DisplayConfig, type EmbeddedField, type EntityCollection, type EntityDirectives, type EntityHandler, type EntityHooks, type EntityUpdateHandler, type EvalDefinition, type FieldConfig, type FieldValue, type FilterConfig, type FormConfig, type GeneratedObject, type HookContext, type ImageConfig, type InputStateConfig, type JSONPathEmbeddedField, type JSONPathField, type JSONSchema, type JSONSchemaProperty, type Job, type JobStatus, type ListOptions, type NavigationGroup, type NestedFieldValue, type OAuthConfig, OPERATORS, type ObjectField, type ParseMDXResult, type ParsedField, type ParsedGenerationReference, type ParsedOperator, type ParsedSchema, type ParsedStateConfig, type ParsedType, type ProcessMDXResult, type PromptField, type RawStateConfig, type ReferenceField, type ReferenceOperator, type RoleConfig, type SchemaAnalytics, type SchemaDefinition, type SchemaErrorHandler, type SchemaExperiment, type SchemaHandler, type SchemaMetadata, type SchemaSettings, SchemaValidationError, type SchemaValidationErrorCode, type SearchConfig, type SectionConfig, type SeedConfig, SerializedFunction, type SourceConfig, type SourceInput, type SpeechConfig, type StateConfig, type StateValidationError, type StateValidationResult, type StringField, type TemplateConfig, type TransitionConfig, type TypeDefinition, type TypeFactory, type TypeReference, UI, type UIConfig, type ViewConfig, combine, convertStringsToPromptsInSeededType, extractCountFromDescription, getReferenceMode, getReferenceTargetType, isJSONPathEmbeddedField, isJSONPathField, isPromptField, isReferenceField, isStringField, isValidJSONPath, parseFieldType, parseGenerationArrayReference, parseGenerationReference, parseIdConfig, parseJSXUI, parseMDX, parseNamespaceFromId, parseOperator, parseSchema, parseSeedConfig, parseStateConfig, processMDX, schemaHash, toJSONSchema, validateStateConfig };