docs: Fix broken links and add missing API documentation (#57)

Author: leoafarias

docs/api-reference/index.mdx

@@ -6,7 +6,7 @@ This page provides a quick reference for the core Ack classes, methods, and anno
 
 ## Core `Ack` Class
 
-Entry point for creating schemas. See [Schema Validation](../core-concepts/typesafe-schemas.mdx).
+Entry point for creating schemas. See [Schema Types](../core-concepts/schemas.mdx).
 
 - `Ack.string()`: Creates a `StringSchema` for validating strings.
 - `Ack.integer()`: Creates an `IntegerSchema` for validating integers.
@@ -54,7 +54,7 @@ Base class for all schema types.
 - `Map<String, Object?> toJsonSchema()`: Converts the schema to a JSON Schema Draft-7 representation.
 - `Map<String, Object?> toMap()`: Serializes the schema for debugging.
 
-See also [Schema Validation](../core-concepts/typesafe-schemas.mdx) for detailed usage examples.
+See also [Schema Types](../core-concepts/schemas.mdx) for detailed usage examples.
 
 ## `StringSchema`
 
@@ -107,6 +107,8 @@ Schemas for validating numbers. See [Number Validation](../core-concepts/validat
 
 - `min(num limit)`: Minimum value (inclusive)
 - `max(num limit)`: Maximum value (inclusive)
+- `greaterThan(num limit)`: Must be greater than limit (exclusive)
+- `lessThan(num limit)`: Must be less than limit (exclusive)
 - `positive()`: Must be greater than 0
 - `negative()`: Must be less than 0
 - `multipleOf(num factor)`: Must be a multiple of the factor
@@ -121,9 +123,10 @@ Schema for validating booleans. Validates `true` and `false` values, with option
 
 Schema for validating arrays. See [List Validation](../core-concepts/validation.mdx#list-constraints).
 
-- `minLength(int min)`: Minimum number of items
-- `maxLength(int max)`: Maximum number of items
-- `length(int exact)`: Exact number of items
+- `minItems(int min)`: Minimum number of items (alias: `minLength`)
+- `maxItems(int max)`: Maximum number of items (alias: `maxLength`)
+- `exactLength(int exact)`: Exact number of items (alias: `length`)
+- `nonEmpty()`: List must have at least one item (alias: `notEmpty`)
 - `unique()`: All items must be unique
 
 ## `ObjectSchema`
@@ -137,6 +140,7 @@ Schema for validating objects (maps). See [Object Validation](../core-concepts/s
 - Use `.partial()` to make all properties optional.
 - Use `.strict()` to disallow additional properties.
 - Use `.passthrough()` to allow additional properties not defined in the schema.
+- Use `.merge(ObjectSchema other)` to combine with another object schema.
 
 ## `SchemaResult<T>`
 
@@ -177,7 +181,7 @@ combinators.
 
 ## Code Generation Annotations
 
-Use the [`ack_generator`](../../packages/ack_generator/README.md) builder to
+Use the [`ack_generator`](https://pub.dev/packages/ack_generator) builder to
 turn annotations into ready-to-use schemas and extension types. After adding
 the annotations below, run:
 
@@ -189,11 +193,9 @@ dart run build_runner build
 
 **Target**: Dart classes
 
-**Generates**: Both a schema constant AND an extension type
+**Generates**: A schema constant only
 
-Annotate a Dart class to automatically generate a validation schema and a strongly typed extension type. The generator analyzes your class fields and creates:
-- A schema constant named `<className>Schema` (e.g., `userSchema`)
-- An extension type named `<ClassName>Type` (e.g., `UserType`)
+Annotate a Dart class to automatically generate a validation schema. The generator analyzes your class fields and creates a schema constant named `<className>Schema` (e.g., `userSchema`).
 
 **Parameters:**
 - `schemaName`: Custom name for the generated schema constant
@@ -215,11 +217,13 @@ class User {
 
 // Generated:
 // - final userSchema = Ack.object({...});
-// - extension type UserType(Map<String, Object?> _data) { ... }
 
 // Usage:
-final user = UserType.parse({'name': 'Alice', 'age': 30});
-print(user.name); // Type-safe String access
+final result = userSchema.safeParse({'name': 'Alice', 'age': 30});
+if (result.isOk) {
+  final data = result.getOrThrow();
+  print(data['name']); // 'Alice'
+}
 ```
 
 ### `@AckType()`
@@ -295,4 +299,4 @@ Every schema can be marked optional through the `optional({bool value = true})`
 - Use `schema.optional(value: false)` to clear the optional flag.
 - Optional affects object-field presence only; combine with `.nullable()` to also allow explicit `null`.
 
-*Refer to the [Schema Validation](../core-concepts/typesafe-schemas.mdx) guide for detailed usage and examples.*
+*Refer to the [Schema Types](../core-concepts/schemas.mdx) guide for detailed usage and examples.*

docs/core-concepts/configuration.mdx

@@ -95,9 +95,9 @@ final signUpSchema = Ack.object({
 
 ## Code Generation Configuration
 
-The `ack_generator` package provides automatic schema generation from annotated classes. This feature is production-ready and available at version 1.0.0-beta.1 and later.
+The `ack_generator` package provides automatic schema generation from annotated classes. This feature is production-ready.
 
-To use code generation, annotate your classes with `@AckModel`. The generator creates both a validation schema and a type-safe extension type. Use `@AckField` for field-level constraints:
+To use code generation, annotate your classes with `@AckModel`. The generator creates a validation schema from your class structure. Use `@AckField` for field-level constraints:
 
 ```dart
 import 'package:ack_annotations/ack_annotations.dart';

docs/core-concepts/json-serialization.mdx

@@ -157,7 +157,7 @@ if (result.isOk) {
 }
 ```
 
-*See the [ack_generator README](../../packages/ack_generator/) for more details on code generation.*
+*See the [ack_generator package](https://pub.dev/packages/ack_generator) for more details on code generation.*
 
 ### Generating Extension Types from Standalone Schemas with `@AckType()`
 

docs/core-concepts/typesafe-schemas.mdx

@@ -9,14 +9,14 @@ produce these typed views.
 
 ## Overview
 
-- `@AckModel()` goes on a **Dart class** and produces **both** a schema constant (e.g., `userSchema`) **and** an extension type named `<ClassName>Type`.
-- `@AckType()` goes on a **schema variable/getter** and produces **only** an extension type (the schema already exists). The type name is derived from the variable name (e.g., `userSchema` → `UserType`).
+- `@AckModel()` goes on a **Dart class** and produces a **schema constant** (e.g., `userSchema`).
+- `@AckType()` goes on a **schema variable/getter** and produces an **extension type** for type-safe access (the schema already exists). The type name is derived from the variable name (e.g., `userSchema` → `UserType`).
 - Both annotations live in `package:ack_annotations` and are processed by the
   `ack_generator` builder via `dart run build_runner build`.
 
-## Typed Schemas from Classes with `@AckModel()`
+## Schema Generation from Classes with `@AckModel()`
 
-Use `@AckModel()` when you have a Dart class that should drive schema generation. The generator creates both the validation schema and a typed wrapper.
+Use `@AckModel()` when you have a Dart class that should drive schema generation. The generator creates a validation schema based on your class structure.
 
 ```dart
 import 'package:ack_annotations/ack_annotations.dart';
@@ -35,12 +35,10 @@ class User {
 Running `dart run build_runner build` writes `user.g.dart` with:
 
 - **Schema constant**: `final userSchema = Ack.object({...});`
-- **Extension type**: `extension type UserType(Map<String, Object?> _data)` that exposes typed getters, `parse`, `safeParse`, `toJson`, `copyWith`, and equality.
 
-You can use either the schema directly or the generated extension type:
+You can use the generated schema for validation:
 
 ```dart
-// Option 1: Use the schema directly (returns Map<String, Object?>)
 final result = userSchema.safeParse(json);
 if (result.isOk) {
   final data = result.getOrThrow();
@@ -49,16 +47,10 @@ if (result.isOk) {
     age: data['age'] as int,
   );
 }
-
-// Option 2: Use the extension type (returns UserType)
-final result = UserType.safeParse(json);
-if (result.isOk) {
-  final user = result.getOrThrow();
-  print(user.name); // -> String (type-safe!)
-  print(user.age);  // -> int (type-safe!)
-}
 ```
 
+For type-safe access without manual casting, add `@AckType()` to the generated schema variable (see below).
+
 ### Discriminated Hierarchies
 
 Annotate an abstract base with `discriminatedKey` and each subtype with a
@@ -145,16 +137,16 @@ behave like `String`, `int`, etc., while object wrappers implement
 
 | Annotation | Target | Generates Schema? | Generates Extension Type? | Use When |
 |------------|--------|-------------------|---------------------------|----------|
-| `@AckModel` | Dart class | ✅ Yes | ✅ Yes | You have a class definition and want both validation and typed access |
-| `@AckType` | Schema variable | ❌ No (uses existing) | ✅ Yes | You already wrote the schema manually and just want typed access |
+| `@AckModel` | Dart class | ✅ Yes | ❌ No | You have a class definition and want schema generation |
+| `@AckType` | Schema variable | ❌ No (uses existing) | ✅ Yes | You have a schema and want type-safe access |
 
 **Examples:**
 
-- Use **`@AckModel`** when you have a Dart class (or class hierarchy) that should drive schema generation. The generator creates both the schema and the extension type.
+- Use **`@AckModel`** when you have a Dart class (or class hierarchy) that should drive schema generation.
 
-- Use **`@AckType`** for hand-written schemas, shared schema fragments, or when you need typed access to a structure that doesn't have a corresponding Dart class.
+- Use **`@AckType`** on schema variables (either hand-written or generated by `@AckModel`) when you want type-safe extension type access.
 
-- **Mix both**: You can reference a `@AckType` schema inside an `@AckModel` class field, or use `@AckModel` classes within `@AckType` schema definitions.
+- **Combine both**: Use `@AckModel` to generate the schema from your class, then use `@AckType` on the generated schema variable if you want extension type wrappers.
 
 ## Build Runner Checklist
 

docs/core-concepts/validation.mdx

@@ -133,24 +133,95 @@ Ensures the string is one of the `allowedValues`.
 Ack.enumString(['active', 'inactive', 'pending'])
 ```
 
+### `literal(String value)`
+Ensures the string exactly matches the specified value.
+```dart
+Ack.string().literal('admin')
+```
+
+### `startsWith(String prefix)`
+Ensures the string starts with the given prefix.
+```dart
+Ack.string().startsWith('https://')
+```
+
+### `endsWith(String suffix)`
+Ensures the string ends with the given suffix.
+```dart
+Ack.string().endsWith('.dart')
+```
+
+### `url()`
+Alias for `uri()`. Ensures the string is a valid URL.
+```dart
+Ack.string().url()
+```
+
+### `ip({int? version})`
+Ensures the string is a valid IP address. Optionally specify version 4 or 6.
+```dart
+Ack.string().ip()          // Any IP (v4 or v6)
+Ack.string().ip(version: 4) // IPv4 only
+Ack.string().ip(version: 6) // IPv6 only
+```
+
+## String Transformations
+
+These methods transform the string value during parsing. They don't add validation constraints but modify the output value.
+
+### `trim()`
+Removes leading and trailing whitespace from the string.
+```dart
+Ack.string().trim()
+// "  hello  " → "hello"
+```
+
+### `toLowerCase()`
+Converts the string to lowercase.
+```dart
+Ack.string().toLowerCase()
+// "HELLO" → "hello"
+```
+
+### `toUpperCase()`
+Converts the string to uppercase.
+```dart
+Ack.string().toUpperCase()
+// "hello" → "HELLO"
+```
+
 ## Number Constraints (Int and Double)
 
 Apply these to [`Ack.integer()`](./schemas.mdx#number-schemas) and [`Ack.double()`](./schemas.mdx#number-schemas) schemas.
 
 ### `min(num limit)`
-Ensures the number is greater than or equal to the `limit`.
+Ensures the number is greater than or equal to the `limit` (inclusive).
 ```dart
 Ack.integer().min(0) // >= 0
 Ack.double().min(0.0) // >= 0.0
 ```
 
 ### `max(num limit)`
-Ensures the number is less than or equal to the `limit`.
+Ensures the number is less than or equal to the `limit` (inclusive).
 ```dart
 Ack.integer().max(100) // <= 100
 Ack.double().max(100.0) // <= 100.0
 ```
 
+### `greaterThan(num limit)`
+Ensures the number is strictly greater than the `limit` (exclusive).
+```dart
+Ack.integer().greaterThan(0) // > 0
+Ack.double().greaterThan(0.0) // > 0.0
+```
+
+### `lessThan(num limit)`
+Ensures the number is strictly less than the `limit` (exclusive).
+```dart
+Ack.integer().lessThan(100) // < 100
+Ack.double().lessThan(100.0) // < 100.0
+```
+
 ### `multipleOf(num factor)`
 Ensures the number is a multiple of the `factor`.
 ```dart
@@ -172,6 +243,18 @@ Ack.integer().negative() // < 0
 Ack.double().negative() // < 0.0
 ```
 
+### `safe()` (Integer only)
+Ensures the integer is within the safe integer range for JavaScript interoperability (-2^53+1 to 2^53-1).
+```dart
+Ack.integer().safe()
+```
+
+### `finite()` (Double only)
+Ensures the double is a finite number (not `infinity` or `NaN`).
+```dart
+Ack.double().finite()
+```
+
 ## List Constraints
 
 Apply these to [`Ack.list()`](./schemas.mdx#list-schema) schemas.

docs/guides/creating-schema-converter-packages.md

@@ -1125,7 +1125,7 @@ dart test  # or flutter test if using Flutter
 
 ## Contributing
 
-For contribution guidelines, see [CONTRIBUTING.md](../../CONTRIBUTING.md) in the root repository.
+For contribution guidelines, see the [CONTRIBUTING.md](https://github.com/btwld/ack/blob/main/CONTRIBUTING.md) in the root repository.
 
 ## License
 

docs/index.mdx

@@ -67,7 +67,7 @@ Ack provides a comprehensive set of features for data validation and transformat
 - **[Validation Rules](/core-concepts/validation)**: Apply constraints like length, range, pattern matching, and custom validators
 - **[Error Handling](/core-concepts/error-handling)**: Get detailed, structured error messages for validation failures
 - **[JSON Serialization](/core-concepts/json-serialization)**: Convert between JSON and typed models
-- **[Schema Validation](/core-concepts/typesafe-schemas)**: Comprehensive schema validation with fluent API
+- **[Configuration](/core-concepts/configuration)**: Schema-level configuration options
 
 ## Next Steps
 

example/pubspec.yaml

@@ -9,10 +9,10 @@ environment:
   sdk: '>=3.8.0 <4.0.0'
 
 dependencies:
-  ack: ^1.0.0-beta.4
+  ack: any
 
 dev_dependencies:
-  ack_generator: ^1.0.0-beta.1
+  ack_generator: any
   build_runner: ^2.4.0
   dart_code_metrics_presets: ^2.22.0
   lints: ^5.0.0

packages/ack_annotations/README.md

@@ -6,16 +6,23 @@ Annotation package for the Ack validation ecosystem. Use these annotations on yo
 
 ## Installation
 
+Add to your `pubspec.yaml` (check [pub.dev](https://pub.dev/packages/ack_annotations) for the latest versions):
+
 ```yaml
 dependencies:
-  ack_annotations: ^1.0.0-beta.1
+  ack_annotations: ^1.0.0
 
 dev_dependencies:
-  ack_generator: ^1.0.0-beta.1
+  ack_generator: ^1.0.0
   build_runner: ^2.4.0
 ```
 
-> Still on the 0.3 alpha line? Use `^0.3.0-alpha.0` for all Ack packages until you migrate to `1.0.0-beta.1`.
+Or use the Dart CLI:
+
+```bash
+dart pub add ack_annotations
+dart pub add --dev ack_generator build_runner
+```
 
 ---
 
@@ -128,7 +135,7 @@ Mix and match annotation-based constraints with the string list syntax from `@Ac
 
 ## Working With build_runner
 
-1. Make sure all Ack packages are on matching versions (either the 0.3 alpha train or the 1.0.0 release).
+1. Make sure all Ack packages are on matching versions.
 2. Run `dart run build_runner build --delete-conflicting-outputs` after changing annotated classes.
 3. For continuous development, `dart run build_runner watch` keeps schemas in sync.
 

packages/ack_annotations/lib/src/ack_model.dart

@@ -1,14 +1,14 @@
 import 'package:meta/meta_meta.dart';
 
-/// Annotation to mark a class for schema and extension type generation.
+/// Annotation to mark a class for schema generation.
 ///
-/// Generates both a schema for validation and an extension type for type-safe access.
-/// For schema variables, use [@AckType] instead.
+/// Generates a schema constant for validating data against your class structure.
+/// For type-safe access to validated data, use [@AckType] on schema variables.
 ///
 /// This annotation can be used in two main ways:
 ///
 /// ## Regular Models
-/// Generate schema validation and extension type for a class:
+/// Generate schema validation for a class:
 /// ```dart
 /// @AckModel()
 /// class User {