edinburgh 0.4.6 → 0.6.0

package/skill/SKILL.md

@@ -26,85 +26,82 @@ import * as E from "edinburgh";
 // Initialize the database (optional, defaults to ".edinburgh")
 E.init("./my-database");
 
-// Define a model
-@E.registerModel
-class User extends E.Model<User> {
-    // Define a primary key (optional, defaults to using the "id" field)
-    static pk = E.primary(User, "id");
-    // Define a unique index on the email field
-    static byEmail = E.unique(User, "email");
-
-    // Define fields with simple types -- they will be type-checked at compile time and validated at runtime.
+const User = E.defineModel("User", class {
     id = E.field(E.identifier);
     name = E.field(E.string);
     age = E.field(E.number);
-    email = E.field(E.opt(E.string)); // TypeScript: undefined | string
-
-    // Link to another instance of this model
-    supervisor = E.field(E.opt(E.link(User)));
-
-    // A field with a more elaborate type. In TypeScript: `User | User[] | "unknown" | "whatever"`
-    something = E.field(E.or(E.link(User), E.array(E.link(User)), E.literal("unknown"), E.literal("whatever")), { default: "unknown" });
-}
+    email = E.field(E.opt(E.string));
+    // Optional link to another instance of this model (needs a function as `User` is not defined yet at this point)
+    supervisor = E.field(E.opt(E.link(() => User)));
+    // A field with a more elaborate type. In TypeScript: `User | User[] | "unknown" | "whatever"`, defaulting to "unknown".
+    something = E.field(
+        E.or(
+            E.link(() => User),
+            E.array(E.link(() => User)),
+            E.literal("unknown"),
+            E.literal("whatever")
+        ),
+        { default: "unknown" }
+    );
+}, {
+    pk: "id",
+    unique: {
+        email: "email",
+    },
+});
 
-// Use in transactions
 await E.transact(() => {
-    const boss = new User({
-        name: "Big Boss",
-        age: 50,
-    });
-    const john = new User({ // Unique 'id' is automatically generated if not provided
-        name: "John Doe", 
+    // Unique 'id' values are auto-generated if not provided
+    const boss = new User({ name: "Big Boss", age: 50 });
+    new User({
+        name: "John Doe",
         age: 41,
         email: "john@example.com",
         supervisor: boss, // Link to another model instance
     });
+    // Newly instantiated models are automatically saved to the database on transaction commit
 });
 
 await E.transact(() => {
     // Query by unique index
-    const john = User.byEmail.get("john@example.com")!;
+  const john = User.getBy("email", "john@example.com")!;
 
     // The transaction will retry if there's a conflict, such as another transaction
     // modifying the same user (from another async function or another process)
     john.age++;
 
     // The supervisor object is lazy loaded on first access
-    console.log(`${john.supervisor!.name} is ${john.name}'s supervisor`);  
+    console.log(`${john.supervisor!.name} is ${john.name}'s supervisor`);
 });    
 ```
 
 ## Tutorial
 
-### TypeScript Configuration
-
-When using TypeScript to transpile to JavaScript, make sure to enable the following options in your `tsconfig.json`:
-
-```json
-{
-    "compilerOptions": {
-        "target": "es2022",
-        "experimentalDecorators": true
-    }
-}
-```
 
 ### Defining Models
 
-Models are classes that extend `E.Model<Self>` and use the `@E.registerModel` decorator:
+A model is defined using the `E.defineModel()` function by passing it..
+- a consistent table name,
+- an (anonymous) class containing `E.field` database properties and optionally regular properties/methods, and
+- optional key/index configuration.
 
 ```typescript
 import * as E from "edinburgh";
 
-@E.registerModel
-class User extends E.Model<User> {
-  static pk = E.primary(User, "id");
-
+const User = E.defineModel("User", class {
   id = E.field(E.identifier);
   name = E.field(E.string);
   email = E.field(E.string);
   age = E.field(E.number);
-}
+}, {
+  pk: "id",
+  unique: {
+    email: "email",
+  },
+});
+// Add this if you want to use User as a type annotation (e.g. `let u: User`).
+// Not needed just to call User.get(), User.find(), new User(), etc.
+type User = InstanceType<typeof User>;
 ```
 
 Instance fields are declared with `E.field(type, options?)`. Available types:
@@ -128,16 +125,13 @@ Instance fields are declared with `E.field(type, options?)`. Available types:
 #### Defaults
 
 ```typescript
-@E.registerModel
-class Post extends E.Model<Post> {
-  static pk = E.primary(Post, "id");
-
-  id = E.field(E.identifier);  // auto-generated
+const Post = E.defineModel("Post", class {
+  id = E.field(E.identifier); // auto-generated
   title = E.field(E.string);
   status = E.field(E.or("draft", "published"), {default: "draft"});
-  tags = E.field(E.array(E.string), {default: () => []});  // use function for mutable defaults
-  createdAt = E.field(E.dateTime);  // dateTime defaults to new Date()
-}
+  tags = E.field(E.array(E.string), {default: () => []}); // use function for mutable defaults
+  createdAt = E.field(E.dateTime); // dateTime defaults to new Date()
+}, { pk: "id" });
 ```
 
 ### Transactions
@@ -150,19 +144,19 @@ E.init("./my-database");
 
 // Create
 await E.transact(() => {
-  const user = new User({name: "Alice", email: "alice@example.com", age: 30});
-  // user.id is auto-generated
+  // User.id is auto-generated
+  new User({name: "Alice", email: "alice@example.com", age: 30});
 });
 
 // Read + Update
 await E.transact(() => {
-  const user = User.byEmail.get("alice@example.com");
+  const user = User.getBy("email", "alice@example.com");
   if (user) user.age++;
 });
 
 // Return values from transactions
 const name = await E.transact(() => {
-  const user = User.byEmail.get("alice@example.com");
+  const user = User.getBy("email", "alice@example.com");
   return user?.name;
 });
 ```
@@ -174,30 +168,29 @@ Transactions auto-retry on conflict (up to 6 times by default). Keep transaction
 Edinburgh supports three index types:
 
 ```typescript
-@E.registerModel
-class Product extends E.Model<Product> {
-  static pk = E.primary(Product, "sku");           // primary: one per model, stores data
-  static byName = E.unique(Product, "name");       // unique: enforces uniqueness + fast lookup
-  static byCategory = E.index(Product, "category");// secondary: non-unique, for queries
-
+const Product = E.defineModel("Product", class {
   sku = E.field(E.string);
   name = E.field(E.string);
   category = E.field(E.string);
   price = E.field(E.number);
-}
+}, {
+  pk: "sku",
+  unique: { name: "name" },
+  index: { category: "category" },
+});
 ```
 
-If no `E.primary()` is declared, Edinburgh auto-creates one on an `id` field (adding `E.identifier` if missing).
+If no `pk` is provided, Edinburgh auto-creates one on an `id` field, adding it as an `E.identifier` field if needed.
 
 #### Lookups
 
 ```typescript
 await E.transact(() => {
   // Primary key lookup
-  const p = Product.pk.get("SKU-001");
+  const p1 = Product.get("SKU-001");
 
   // Unique index lookup
-  const p2 = Product.byName.get("Widget");
+  const p2 = Product.getBy("name", "Widget");
 
   // All return undefined if not found
 });
@@ -205,54 +198,53 @@ await E.transact(() => {
 
 #### Range Queries
 
-All index types support `.find()` for range iteration:
+Primary-key queries use `.find()`. Named unique and secondary indexes use `.findBy(name, ...)`:
 
 ```typescript
 await E.transact(() => {
   // Exact match
-  for (const p of Product.byCategory.find({is: "electronics"})) {
+  for (const p of Product.findBy("category", {is: "electronics"})) {
     console.log(p.name);
   }
 
   // Range (inclusive)
-  for (const p of Product.pk.find({from: "A", to: "M"})) {
+  for (const p of Product.find({from: "A", to: "M"})) {
     console.log(p.sku);
   }
 
   // Exclusive bounds
-  for (const p of Product.pk.find({after: "A", before: "M"})) { ... }
+  for (const p of Product.find({after: "A", before: "M"})) { ... }
 
   // Open-ended
-  for (const p of Product.pk.find({from: "M"})) { ... }
+  for (const p of Product.find({from: "M"})) { ... }
 
   // Reverse
-  for (const p of Product.pk.find({reverse: true})) { ... }
+  for (const p of Product.find({reverse: true})) { ... }
 
   // Count and fetch helpers
-  const count = Product.byCategory.find({is: "electronics"}).count();
-  const first = Product.byCategory.find({is: "electronics"}).fetch(); // first match or undefined
+  const count = Product.findBy("category", {is: "electronics"}).count();
+  const first = Product.findBy("category", {is: "electronics"}).fetch(); // first match or undefined
 });
 ```
 
-#### Composite Indexes
+#### Composite Primary Keys
 
 ```typescript
-@E.registerModel
-class Event extends E.Model<Event> {
-  static pk = E.primary(Event, ["year", "month", "id"]);
-
+const Event = E.defineModel("Event", class {
   year = E.field(E.number);
   month = E.field(E.number);
   id = E.field(E.identifier);
   title = E.field(E.string);
-}
+}, {
+  pk: ["year", "month", "id"] as const,
+});
 
 await E.transact(() => {
   // Prefix matching — find all events in 2025
-  for (const e of Event.pk.find({is: [2025]})) { ... }
+  for (const e of Event.find({is: [2025]})) { ... }
 
   // Find events in March 2025
-  for (const e of Event.pk.find({is: [2025, 3]})) { ... }
+  for (const e of Event.find({is: [2025, 3]})) { ... }
 });
 ```
 
@@ -261,10 +253,7 @@ await E.transact(() => {
 You can freely add regular methods, getters, and other non-persistent properties to model classes. These work normally in JavaScript but are **not stored in the database** and **not synchronized** across transactions or processes.
 
 ```typescript
-@E.registerModel
-class User extends E.Model<User> {
-  static pk = E.primary(User, "id");
-  id = E.field(E.identifier);
+const User = E.defineModel("User", class {
   firstName = E.field(E.string);
   lastName = E.field(E.string);
 
@@ -279,70 +268,68 @@ class User extends E.Model<User> {
   greet(): string {
     return `Hello, ${this.fullName}!`;
   }
-}
+});
 ```
 
 #### Computed Indexes
 
-Instead of naming fields, you can pass a **function** to `E.unique()` or `E.index()`. The function receives a model instance and returns an **array** of index key values. Each element creates a separate index entry, enabling multi-value indexes. Return `[]` to skip indexing for that instance (partial index).
+Instead of naming fields, you can pass a function as an index specification. The function receives a model instance and returns an **array** of index key values. Each element creates a separate index entry, enabling multi-value indexes. Return `[]` to skip indexing for that instance (partial index).
 
 ```typescript
-@E.registerModel
-class Article extends E.Model<Article> {
-  static pk = E.primary(Article, "id");
-  static byFullName = E.unique(Article, (a: Article) => [`${a.firstName} ${a.lastName}`]);
-  static byWord = E.index(Article, (a: Article) => a.title.toLowerCase().split(" "));
-  static byDomain = E.index(Article, (a: Article) => a.email ? [a.email.split("@")[1]] : []);
-
+const Article = E.defineModel("Article", class {
   id = E.field(E.identifier);
   firstName = E.field(E.string);
   lastName = E.field(E.string);
   title = E.field(E.string);
   email = E.field(E.opt(E.string));
-}
+}, {
+  pk: "id",
+  unique: {
+    fullName: (a: any) => [`${a.firstName} ${a.lastName}`], // computed covering unique index
+  },
+  index: {
+    domain: (a: any) => a.email ? [a.email.split("@")[1]] : [], // computed partial index
+    word: (a: any) => a.title.toLowerCase().split(" "), // computed multi-index
+  },
+});
 
 await E.transact(() => {
   new Article({ firstName: "Jane", lastName: "Doe", title: "Hello World", email: "jane@acme.com" });
 
   // Lookup via computed unique index
-  const jane = Article.byFullName.get("Jane Doe");
+  const jane = Article.getBy("fullName", "Jane Doe");
 
   // Multi-value: each word in the title is indexed separately
-  for (const a of Article.byWord.find({is: "hello"})) { ... }
+  for (const a of Article.findBy("word", {is: "hello"})) { ... }
 
   // Partial index: articles without email are skipped
-  for (const a of Article.byDomain.find({is: "acme.com"})) { ... }
+  for (const a of Article.findBy("domain", {is: "acme.com"})) { ... }
 });
 ```
 
-Computed indexes also support `find()` range queries and `batchProcess()`, just like field-based indexes.
-
-### Relationships (Links)
+### Relationships
 
-Use `E.link(Model)` for foreign keys:
+Use `E.link(Model)` for foreign keys. Use a thunk (a function that just returns a value) for forward references when needed:
 
 ```typescript
-@E.registerModel
-class Author extends E.Model<Author> {
-  static pk = E.primary(Author, "id");
+const Author = E.defineModel("Author", class {
   id = E.field(E.identifier);
   name = E.field(E.string);
-}
+}, { pk: "id" });
 
-@E.registerModel
-class Book extends E.Model<Book> {
-  static pk = E.primary(Book, "id");
+const Book = E.defineModel("Book", class {
   id = E.field(E.identifier);
   title = E.field(E.string);
   author = E.field(E.link(Author));
-}
+}, { pk: "id" });
 
 await E.transact(() => {
   const author = new Author({name: "Tolkien"});
   const book = new Book({title: "The Hobbit", author});
 
   // Later: linked models are lazy-loaded on property access
-  const b = Book.pk.get(book.id)!;
+  const b = Book.get(book.id)!;
+  console.log(b.author.id);    // no need to load yet..
   console.log(b.author.name);  // loads Author automatically (~1µs)
 });
 ```
@@ -351,7 +338,7 @@ await E.transact(() => {
 
 ```typescript
 await E.transact(() => {
-  const user = User.pk.get(someId);
+  const user = User.get(someId);
   if (user) user.delete();
 });
 ```
@@ -369,10 +356,16 @@ await E.transact(() => {
   user.preventPersist(); // exclude from commit
 });
 
-// findAll iterates all instances
+// find() iterates all instances (or use range options)
 await E.transact(() => {
-  for (const user of User.findAll()) { ... }
-  for (const user of User.findAll({reverse: true})) { ... }
+  for (const user of User.find()) { ... }
+  for (const user of User.find({reverse: true})) { ... }
+
+  // {fetch: 'first'} returns a single instance or undefined
+  const first = User.find({fetch: 'first'});
+
+  // {fetch: 'single'} returns a single instance, or throws if there are none or more than one
+  const only = User.find({fetch: 'single'});
 });
 
 // replaceInto: upsert by primary key
@@ -386,7 +379,7 @@ await E.transact(() => {
 For large datasets, `batchProcess` auto-commits in batches:
 
 ```typescript
-await Product.byCategory.batchProcess({is: "old"}, (product) => {
+await Product.batchProcess({ limitRows: 1000 }, (product) => {
   product.category = "archived";
 });
 // Commits every ~1 second or 4096 rows (configurable via limitSeconds, limitRows)
@@ -394,12 +387,10 @@ await Product.byCategory.batchProcess({is: "old"}, (product) => {
 
 ### Lazy Schema Migrations
 
-When you change a model's schema, Edinburgh will lazily try to migrate old records on access. This allows you to deploy code changes without downtime or a separate migration step. Optionally, you may provide a `static migrate(record: Record<string, any>)` function on the model to transform old records during lazy migration. If there is a migration error (like a new field without a default value, or an incompatible type change), a run-time error is thrown when loading the affected model instance.
+When you change a model's schema, Edinburgh lazily migrates old records on access. You can provide a `static migrate(record)` function to transform old rows:
 
 ```typescript
-@E.registerModel
-class User extends E.Model<User> {
-  static pk = E.primary(User, "id");
+const UserV2 = E.defineModel("User", class {
   id = E.field(E.identifier);
   name = E.field(E.string);
   role = E.field(E.string);  // newly added field
@@ -407,7 +398,7 @@ class User extends E.Model<User> {
   static migrate(record: Record<string, any>) {
     record.role ??= record.name.indexOf("admin") >= 0 ? "admin" : "user"; // set role based on name for old records
   }
-}
+})
 ```
 
 Edinburgh will lazily (re)run the `migrate` function on an instance whenever its implementation (the literal function code) has changed. For robustness, make sure that your `migrate` function...
@@ -442,9 +433,7 @@ console.log(result.secondaries);  // { User: 1500 }
 Compute derived fields before data is written:
 
 ```typescript
-@E.registerModel
-class Article extends E.Model<Article> {
-  static pk = E.primary(Article, "id");
+const Article = E.defineModel("Article", class {
   id = E.field(E.identifier);
   title = E.field(E.string);
   slug = E.field(E.string);
@@ -452,7 +441,7 @@ class Article extends E.Model<Article> {
   preCommit() {
     this.slug = this.title.toLowerCase().replace(/\s+/g, "-");
   }
-}
+});
 ```
 
 ### Change Tracking
@@ -493,9 +482,12 @@ ln -s ../../node_modules/edinburgh/skill .claude/skills/edinburgh
 
 The following is auto-generated from `src/edinburgh.ts`:
 
-### scheduleInit · function
+### currentTxn · function
 
-**Signature:** `() => void`
+Returns the current transaction from AsyncLocalStorage.
+Throws if called outside a transact() callback.
+
+**Signature:** `() => Transaction`
 
 ### [init](init.md) · function
 
@@ -516,72 +508,53 @@ The default value is 6. Setting it to 0 will disable retries and cause transacti
 
 Set a callback function to be called after a model is saved and committed.
 
-### deleteEverything · function
-
-**Signature:** `() => Promise<void>`
+### Model · class
 
-### [Model](Model.md) · abstract class
+**Type:** `typeof ModelBase`
 
-[object Object],[object Object],[object Object],[object Object],[object Object]
+### [ModelClass](ModelClass.md) · class
 
-#### Model.tableName · static property
+Runtime base constructor for model classes returned by `defineModel()`.
 
-The database table name (defaults to class name).
+### [AnyModelClass](AnyModelClass.md) · type
 
-**Type:** `string`
+A model constructor with its generic information erased.
 
-#### Model.override · static property
+### [ModelBase](ModelBase.md) · abstract class
 
-When true, registerModel replaces an existing model with the same tableName.
+Base class for all database models in the Edinburgh ORM.
 
-**Type:** `boolean`
+### [Schema Evolution](Schema Evolution.md)
 
-#### Model.fields · static property
+Edinburgh tracks the schema version of each model automatically. When you add, remove, or
+change the types of fields, or add/remove indexes, Edinburgh detects the new schema version.
 
-Field configuration metadata.
+### [Lifecycle Hooks](Lifecycle Hooks.md)
 
-**Type:** `Record<string | number | symbol, FieldConfig<unknown>>`
+- **`static migrate(record)`**: Called when deserializing rows written with an older schema
+  version. Receives a plain record object; mutate it in-place to match the current schema.
 
-#### [Model.migrate](Model_migrate.md) · static method
+#### [ModelBase.migrate](Lifecycle Hooks_migrate.md) · static method
 
 Optional migration function called when deserializing rows written with an older schema version.
-Receives a plain record with all fields (primary key fields + value fields) and should mutate it
-in-place to match the current schema.
-
-#### Model.initFields · static method
-
-Transform the model's `E.field` properties into the appropriate JavaScript properties. Normally this is done
-automatically when using `transact()`, but in case you need to access `Model.fields` directly before the first
-transaction, you can call this method manually.
-
-**Signature:** `(reset?: boolean) => void`
-
-**Parameters:**
-
-- `reset?: boolean`
+Receives a plain record with all fields and should mutate it in-place to match the current schema.
+It runs during lazy loading and during `runMigration()`. Changing this method creates a new schema version.
+If it updates values used by secondary or unique indexes, those index entries are refreshed only by `runMigration()`.
 
-#### [Model.findAll](Model_findAll.md) · static method
-
-Find all instances of this model in the database, ordered by primary key.
-
-#### [Model.replaceInto](Model_replaceInto.md) · static method
-
-Load an existing instance by primary key and update it, or create a new one.
-
-#### [model.preCommit](Model_preCommit.md) · method
+#### [modelBase.preCommit](Lifecycle Hooks_preCommit.md) · method
 
 Optional hook called on each modified instance right before the transaction commits.
 Runs before data is written to disk, so changes made here are included in the commit.
 
-#### model.getPrimaryKey · method
+#### modelBase.getPrimaryKey · method
 
 **Signature:** `() => Uint8Array<ArrayBufferLike>`
 
 **Returns:** The primary key for this instance.
 
-#### [model.getPrimaryKeyHash](Model_getPrimaryKeyHash.md) · method
+#### [modelBase.getPrimaryKeyHash](Lifecycle Hooks_getPrimaryKeyHash.md) · method
 
-#### model.isLazyField · method
+#### modelBase.isLazyField · method
 
 **Signature:** `(field: keyof this) => boolean`
 
@@ -589,38 +562,42 @@ Runs before data is written to disk, so changes made here are included in the co
 
 - `field: keyof this`
 
-#### [model.preventPersist](Model_preventPersist.md) · method
+#### [modelBase.preventPersist](Lifecycle Hooks_preventPersist.md) · method
 
 Prevent this instance from being persisted to the database.
 
-#### [model.delete](Model_delete.md) · method
+#### [modelBase.delete](Lifecycle Hooks_delete.md) · method
 
 Delete this model instance from the database.
 
-#### [model.validate](Model_validate.md) · method
+#### [modelBase.validate](Lifecycle Hooks_validate.md) · method
 
 Validate all fields in this model instance.
 
-#### [model.isValid](Model_isValid.md) · method
+#### [modelBase.isValid](Lifecycle Hooks_isValid.md) · method
 
 Check if this model instance is valid.
 
-#### model.getState · method
+#### modelBase.getState · method
 
 **Signature:** `() => "created" | "deleted" | "loaded" | "lazy"`
 
-#### model.toString · method
+#### modelBase.toString · method
 
 **Signature:** `() => string`
 
-#### model.[Symbol.for('nodejs.util.inspect.custom')] · method
+#### modelBase.[Symbol.for('nodejs.util.inspect.custom')] · method
 
 **Signature:** `() => string`
 
-### [registerModel](registerModel.md) · function
+### [defineModel](defineModel.md) · function
 
 Register a model class with the Edinburgh ORM system.
 
+### [deleteEverything](deleteEverything.md) · function
+
+Delete every key/value entry in the database and reinitialize all registered models.
+
 ### [field](field.md) · function
 
 Create a field definition for a model property.
@@ -699,79 +676,126 @@ Create a literal type wrapper for a constant value.
 
 Create a link type wrapper for model relationships.
 
-### [index](index.md) · function
+### dump · function
 
-Create a secondary index on model fields, or a computed secondary index using a function.
+**Signature:** `() => void`
 
-### [primary](primary.md) · function
+### [FindOptions](FindOptions.md) · type
 
-Create a primary index on model fields.
+Range-query options accepted by `find()`, `findBy()`, `batchProcess()`, and `batchProcessBy()`.
 
-### [unique](unique.md) · function
+### IndexRangeIterator · class
 
-Create a unique index on model fields, or a computed unique index using a function.
+Iterator for range queries on indexes.
+Handles common iteration logic for both primary and unique indexes.
+Extends built-in Iterator to provide map/filter/reduce/toArray/etc.
 
-### [dump](dump.md) · function
+**Type Parameters:**
 
-Dump database contents for debugging.
+- `ITEM`
 
-### [BaseIndex](BaseIndex.md) · abstract class
+#### indexRangeIterator.[Symbol.iterator] · method
 
-Base class for database indexes for efficient lookups on model fields.
+**Signature:** `() => this`
 
-#### [baseIndex.find](BaseIndex_find.md) · method
+#### indexRangeIterator.next · method
 
-#### [baseIndex.batchProcess](BaseIndex_batchProcess.md) · method
+**Signature:** `() => IteratorResult<ITEM, any>`
 
-[object Object],[object Object],[object Object]
+#### indexRangeIterator.count · method
 
-#### baseIndex.toString · method
+**Signature:** `() => number`
 
-**Signature:** `() => string`
+#### indexRangeIterator.fetch · method
 
-### [UniqueIndex](UniqueIndex.md) · class
+**Signature:** `() => ITEM`
 
-Unique index that stores references to the primary key.
+### Change · type
 
-#### [uniqueIndex.get](UniqueIndex_get.md) · method
+**Type:** `Record<any, any> | "created" | "deleted"`
 
-Get a model instance by unique index key values.
+### FieldConfig · interface
 
-### [PrimaryIndex](PrimaryIndex.md) · class
+Configuration interface for model fields.
 
-Primary index that stores the actual model data.
+**Type Parameters:**
 
-#### [primaryIndex.get](PrimaryIndex_get.md) · method
+- `T` - The field type.
 
-Get a model instance by primary key values.
+#### fieldConfig.type · member
 
-#### [primaryIndex.getLazy](PrimaryIndex_getLazy.md) · method
+The type wrapper that defines how this field is serialized/validated.
 
-Does the same as as `get()`, but will delay loading the instance from disk until the first
-property access. In case it turns out the instance doesn't exist, an error will be thrown
-at that time.
+**Type:** `TypeWrapper<T>`
 
-### [SecondaryIndex](SecondaryIndex.md) · class
+#### fieldConfig.description · member
 
-Secondary index for non-unique lookups.
+Optional human-readable description of the field.
 
-### Change · type
+**Type:** `string`
 
-**Type:** `Record<any, any> | "created" | "deleted"`
+#### fieldConfig.default · member
 
-### Transaction · interface
+Optional default value or function that generates default values.
 
-#### transaction.id · member
+**Type:** `T | ((model: Record<string, any>) => T)`
 
-**Type:** `number`
+### TypeWrapper · abstract class
 
-#### transaction.instances · member
+**Type Parameters:**
+
+- `T` - The TypeScript type this wrapper represents.
+
+#### typeWrapper.kind · abstract property
+
+A string identifier for this type, used during serialization
+
+**Type:** `string`
+
+#### [typeWrapper.serialize](TypeWrapper_serialize.md) · abstract method
+
+Serialize a value from an object property to a Pack.
+
+#### [typeWrapper.deserialize](TypeWrapper_deserialize.md) · abstract method
+
+Deserialize a value from a Pack into an object property.
+
+#### [typeWrapper.getError](TypeWrapper_getError.md) · abstract method
+
+Validate a value.
+
+#### [typeWrapper.serializeType](TypeWrapper_serializeType.md) · method
+
+Serialize type metadata to a Pack (for schema serialization).
+
+#### [typeWrapper.containsNull](TypeWrapper_containsNull.md) · method
+
+Check if indexing should be skipped for this field value.
+
+#### typeWrapper.toString · method
 
-**Type:** `Set<Model<unknown>>`
+**Signature:** `() => string`
+
+#### typeWrapper.clone · method
+
+**Signature:** `(value: T) => T`
+
+**Parameters:**
+
+- `value: T`
+
+#### typeWrapper.equals · method
+
+**Signature:** `(value1: T, value2: T) => boolean`
+
+**Parameters:**
+
+- `value1: T`
+- `value2: T`
 
-#### transaction.instancesByPk · member
+#### typeWrapper.getLinkedModel · method
 
-**Type:** `Map<number, Model<unknown>>`
+**Signature:** `() => AnyModelClass`
 
 ### [DatabaseError](DatabaseError.md) · constant
 
@@ -853,3 +877,17 @@ Number of orphaned index entries deleted.
 
 **Type:** `number`
 
+### Transaction · interface
+
+#### transaction.id · member
+
+**Type:** `number`
+
+#### transaction.instances · member
+
+**Type:** `Map<number, ModelBase>`
+
+### txnStorage · constant
+
+**Value:** `AsyncLocalStorage<Transaction>`
+