@cosmneo/onion-lasagna 0.1.0

package/dist/base-uuid-v7.vo-BPGEIWLM.d.ts

@@ -0,0 +1,799 @@
+import { a as BoundValidator } from './base-dto.class-D7W9iqoU.js';
+
+/**
+ * Sentinel value to skip validation in Value Object constructors.
+ *
+ * Use this when creating a Value Object from already-validated data,
+ * such as when reconstituting from a database or creating derived VOs.
+ *
+ * @example
+ * ```typescript
+ * // In a VO that wraps a validated value
+ * class Email extends BaseValueObject<string> {
+ *   private constructor(value: string, validator: BoundValidator<string> | SkipValueObjectValidation) {
+ *     super(value, validator);
+ *   }
+ *
+ *   // Public factory validates
+ *   static create(value: string): Email {
+ *     return new Email(value, emailValidator);
+ *   }
+ *
+ *   // Internal factory skips validation (data already validated)
+ *   static fromPersistence(value: string): Email {
+ *     return new Email(value, SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ * }
+ * ```
+ */
+declare const SKIP_VALUE_OBJECT_VALIDATION: "skip value object validation";
+/** Type for the skip validation sentinel. */
+type SkipValueObjectValidation = typeof SKIP_VALUE_OBJECT_VALIDATION;
+/**
+ * Base class for Domain-Driven Design Value Objects.
+ *
+ * Value Objects are immutable domain primitives that are compared by value,
+ * not by reference. They encapsulate validation and domain logic for
+ * primitive concepts like Email, Money, Address, etc.
+ *
+ * Key characteristics:
+ * - **Immutable**: Value cannot be changed after construction
+ * - **Equality by value**: Two VOs with the same value are considered equal
+ * - **Self-validating**: Validation runs at construction time
+ *
+ * @typeParam T - The underlying value type
+ *
+ * @example
+ * ```typescript
+ * class Email extends BaseValueObject<string> {
+ *   private constructor(value: string, validator: BoundValidator<string> | SkipValueObjectValidation) {
+ *     super(value, validator);
+ *   }
+ *
+ *   static create(value: string): Email {
+ *     return new Email(value, emailValidator);
+ *   }
+ *
+ *   get domain(): string {
+ *     return this.value.split('@')[1];
+ *   }
+ * }
+ *
+ * const email1 = Email.create('user@example.com');
+ * const email2 = Email.create('user@example.com');
+ * email1.equals(email2); // true
+ * ```
+ */
+declare class BaseValueObject<T> {
+    private readonly _value;
+    /**
+     * Creates a new Value Object instance.
+     *
+     * @param value - The raw value to wrap
+     * @param validator - A bound validator or SKIP_VALUE_OBJECT_VALIDATION to bypass
+     * @throws {ObjectValidationError} When validation fails
+     */
+    protected constructor(value: T, validator: BoundValidator<T> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+    /**
+     * Compares this Value Object with another for equality.
+     *
+     * Uses deep equality comparison to handle nested objects, arrays, and dates.
+     * Two Value Objects are equal if their underlying values are deeply equal.
+     *
+     * @param other - The Value Object to compare with
+     * @returns `true` if the values are deeply equal, `false` otherwise
+     */
+    equals(other: BaseValueObject<T>): boolean;
+    /**
+     * The underlying immutable value.
+     *
+     * @returns The wrapped value of type T
+     */
+    get value(): T;
+}
+
+/**
+ * Base UUID v4 value object for random entity identifiers.
+ *
+ * UUID v4 is a randomly generated UUID, suitable for identifiers where
+ * time-ordering is not required. For time-sortable IDs, use {@link BaseUuidV7Vo}.
+ *
+ * **Use Cases:**
+ * - User IDs (for audit tracking)
+ * - Session tokens
+ * - Correlation IDs
+ * - Any identifier where time-ordering doesn't matter
+ *
+ * @example Generating a new ID
+ * ```typescript
+ * const id = BaseUuidV4Vo.generate();
+ * console.log(id.value); // e.g., "550e8400-e29b-41d4-a716-446655440000"
+ * ```
+ *
+ * @example Extending for validation
+ * ```typescript
+ * class UserIdVo extends BaseUuidV4Vo {
+ *   static create(value: string): UserIdVo {
+ *     return new UserIdVo(value, uuidValidator);
+ *   }
+ *
+ *   static generate(): UserIdVo {
+ *     return new UserIdVo(v4(), SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Value object for UUID v4 identifiers.
+ *
+ * Provides a `generate()` factory method that creates new random UUIDs.
+ *
+ * @extends BaseValueObject<string>
+ */
+declare class BaseUuidV4Vo extends BaseValueObject<string> {
+    /**
+     * Creates a new BaseUuidV4Vo instance.
+     *
+     * @param value - The UUID v4 string value
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: string, validator: BoundValidator<string> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+    /**
+     * Generates a new UUID v4 value object.
+     *
+     * Creates a random UUID, skipping validation since the
+     * `uuid` library guarantees format.
+     *
+     * @returns A new BaseUuidV4Vo with a freshly generated UUID
+     */
+    static generate(): BaseUuidV4Vo;
+    /**
+     * Creates a UUID v4 value object from an existing string.
+     *
+     * **Important:** This base implementation skips validation and accepts
+     * any string value. Subclasses should override this method with a
+     * validator to ensure UUID format correctness.
+     *
+     * @param value - The UUID v4 string value (not validated at base level)
+     * @returns A new BaseUuidV4Vo with the provided value
+     *
+     * @example Subclass with validation (recommended)
+     * ```typescript
+     * class UserId extends BaseUuidV4Vo {
+     *   static override create(value: string): UserId {
+     *     return new UserId(value, uuidV4Validator);
+     *   }
+     * }
+     * ```
+     *
+     * @see generate - For creating new UUIDs (always valid)
+     */
+    static create(value: string): BaseUuidV4Vo;
+}
+
+/**
+ * Base audit user tracking value object.
+ *
+ * Tracks which user created and last updated an entity. User IDs are
+ * optional to support system-initiated operations where no user context
+ * is available.
+ *
+ * @example Extending for a validator-specific implementation
+ * ```typescript
+ * class AuditByVo extends BaseAuditByVo {
+ *   static create(opts?: {
+ *     createdBy?: UuidV4Vo;
+ *     updatedBy?: UuidV4Vo;
+ *   }): AuditByVo {
+ *     return new AuditByVo({
+ *       createdBy: opts?.createdBy,
+ *       updatedBy: opts?.updatedBy ?? opts?.createdBy,
+ *     }, SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ *
+ *   update(updatedBy: UuidV4Vo): AuditByVo {
+ *     return new AuditByVo({
+ *       createdBy: this.createdBy,
+ *       updatedBy,
+ *     }, SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Abstract base class for audit user tracking value objects.
+ *
+ * @extends BaseValueObject
+ */
+declare abstract class BaseAuditByVo extends BaseValueObject<{
+    createdBy?: BaseUuidV4Vo;
+    updatedBy?: BaseUuidV4Vo;
+}> {
+    /**
+     * Creates a new BaseAuditByVo instance.
+     *
+     * @param value - The user tracking values
+     * @param value.createdBy - User who created the entity (optional for system ops)
+     * @param value.updatedBy - User who last updated the entity (optional)
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: {
+        createdBy?: BaseUuidV4Vo;
+        updatedBy?: BaseUuidV4Vo;
+    }, validator: BoundValidator<{
+        createdBy?: BaseUuidV4Vo;
+        updatedBy?: BaseUuidV4Vo;
+    }> | SkipValueObjectValidation);
+    /**
+     * Creates a new audit user tracking with updated user ID.
+     *
+     * @param updatedBy - The user ID performing the update
+     * @returns A new immutable audit user tracking instance
+     */
+    abstract update(updatedBy: BaseUuidV4Vo): BaseAuditByVo;
+    /**
+     * The user ID who created the entity.
+     * Returns `undefined` for system-created entities.
+     */
+    get createdBy(): BaseUuidV4Vo | undefined;
+    /**
+     * The user ID who last updated the entity.
+     * Returns `undefined` for system-updated entities.
+     */
+    get updatedBy(): BaseUuidV4Vo | undefined;
+}
+
+/**
+ * Base audit timestamp value object.
+ *
+ * Tracks when an entity was created and last updated. Enforces the
+ * domain invariant that `updatedAt` cannot be earlier than `createdAt`.
+ *
+ * **Domain Invariant:**
+ * The constructor throws {@link InvariantViolationError} if
+ * `updatedAt < createdAt`, ensuring timestamps are always valid.
+ *
+ * **Immutability:**
+ * Date getters return cloned Date objects to prevent external mutation.
+ *
+ * @example Extending for a validator-specific implementation
+ * ```typescript
+ * class AuditOnVo extends BaseAuditOnVo {
+ *   static create(opts?: { createdAt?: Date; updatedAt?: Date }): AuditOnVo {
+ *     const now = new Date();
+ *     return new AuditOnVo({
+ *       createdAt: opts?.createdAt ?? now,
+ *       updatedAt: opts?.updatedAt ?? now,
+ *     }, SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ *
+ *   update(): AuditOnVo {
+ *     return new AuditOnVo({
+ *       createdAt: this.createdAt,
+ *       updatedAt: new Date(),
+ *     }, SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Abstract base class for audit timestamp value objects.
+ *
+ * @extends BaseValueObject
+ * @throws {InvariantViolationError} When `updatedAt` is earlier than `createdAt`
+ */
+declare abstract class BaseAuditOnVo extends BaseValueObject<{
+    createdAt: Date;
+    updatedAt: Date;
+}> {
+    /**
+     * Creates a new BaseAuditOnVo instance.
+     *
+     * @param value - The timestamp values
+     * @param value.createdAt - When the entity was created
+     * @param value.updatedAt - When the entity was last updated
+     * @param validator - Bound validator or skip validation symbol
+     * @throws {InvariantViolationError} When `updatedAt < createdAt`
+     */
+    protected constructor(value: {
+        createdAt: Date;
+        updatedAt: Date;
+    }, validator: BoundValidator<{
+        createdAt: Date;
+        updatedAt: Date;
+    }> | SkipValueObjectValidation);
+    /**
+     * Creates a new audit timestamp with current time as updatedAt.
+     *
+     * @returns A new immutable audit timestamp instance
+     */
+    abstract update(): BaseAuditOnVo;
+    /**
+     * When the entity was created.
+     * Returns a cloned Date to prevent mutation.
+     */
+    get createdAt(): Date;
+    /**
+     * When the entity was last updated.
+     * Returns a cloned Date to prevent mutation.
+     */
+    get updatedAt(): Date;
+}
+
+/**
+ * Base audit info value object for entity tracking.
+ *
+ * Composite value object that combines timestamp tracking ({@link BaseAuditOnVo})
+ * and user tracking ({@link BaseAuditByVo}) into a single immutable audit record.
+ * Used for tracking entity creation and modification history.
+ *
+ * **Composition:**
+ * - `on`: {@link BaseAuditOnVo} - timestamps (createdAt, updatedAt)
+ * - `by`: {@link BaseAuditByVo} - user IDs (createdBy, updatedBy)
+ *
+ * **Immutability:**
+ * Date getters return cloned Date objects to prevent external mutation.
+ *
+ * @example Extending for a validator-specific implementation
+ * ```typescript
+ * class AuditInfoVo extends BaseAuditInfoVo {
+ *   static create(createdBy?: UuidV4Vo): AuditInfoVo {
+ *     const now = new Date();
+ *     return new AuditInfoVo({
+ *       by: AuditByVo.create({ createdBy, updatedBy: createdBy }),
+ *       on: AuditOnVo.create({ createdAt: now, updatedAt: now }),
+ *     }, SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ *
+ *   update(updatedBy: UuidV4Vo): AuditInfoVo {
+ *     return new AuditInfoVo({
+ *       by: this.value.by.update(updatedBy),
+ *       on: this.value.on.update(),
+ *     }, SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ * }
+ * ```
+ *
+ * @example Using with an entity
+ * ```typescript
+ * class User {
+ *   constructor(
+ *     public readonly id: UuidV7Vo,
+ *     public readonly name: string,
+ *     public readonly audit: AuditInfoVo,
+ *   ) {}
+ *
+ *   updateName(name: string, updatedBy: UuidV4Vo): User {
+ *     return new User(this.id, name, this.audit.update(updatedBy));
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Abstract base class for audit information value objects.
+ *
+ * Extend this class and implement the `update()` method with your
+ * validator-specific child VOs.
+ *
+ * @extends BaseValueObject
+ */
+declare abstract class BaseAuditInfoVo extends BaseValueObject<{
+    by: BaseAuditByVo;
+    on: BaseAuditOnVo;
+}> {
+    /**
+     * Creates a new BaseAuditInfoVo instance.
+     *
+     * @param value - Composite value containing audit by and on VOs
+     * @param value.by - User tracking value object
+     * @param value.on - Timestamp tracking value object
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: {
+        by: BaseAuditByVo;
+        on: BaseAuditOnVo;
+    }, validator: BoundValidator<{
+        by: BaseAuditByVo;
+        on: BaseAuditOnVo;
+    }> | SkipValueObjectValidation);
+    /**
+     * Creates a new audit info with updated timestamp and user.
+     *
+     * @param updatedBy - The user ID performing the update
+     * @returns A new immutable audit info instance
+     */
+    abstract update(updatedBy: BaseUuidV4Vo): BaseAuditInfoVo;
+    /**
+     * The user ID who created the entity.
+     * Returns `undefined` for system-created entities.
+     */
+    get createdBy(): BaseUuidV4Vo | undefined;
+    /**
+     * The timestamp when the entity was created.
+     * Returns a cloned Date to prevent mutation.
+     */
+    get createdAt(): Date;
+    /**
+     * The user ID who last updated the entity.
+     * Returns `undefined` for system-updated entities.
+     */
+    get updatedBy(): BaseUuidV4Vo | undefined;
+    /**
+     * The timestamp when the entity was last updated.
+     * Returns a cloned Date to prevent mutation.
+     */
+    get updatedAt(): Date;
+    /**
+     * Whether the entity has been modified since creation.
+     *
+     * Compares both timestamps and user IDs. Returns `true` if either:
+     * - The updatedAt timestamp differs from createdAt
+     * - The updatedBy user differs from createdBy
+     *
+     * Note: When both createdBy and updatedBy are undefined (system-created
+     * entities), this correctly returns false for the user comparison.
+     */
+    get isModified(): boolean;
+    /**
+     * Alias for `updatedBy` for semantic clarity.
+     */
+    get lastModifiedBy(): BaseUuidV4Vo | undefined;
+    /**
+     * Alias for `updatedAt` for semantic clarity.
+     */
+    get lastModifiedAt(): Date;
+}
+
+/**
+ * Base email value object.
+ *
+ * Represents a validated email address. Extend this class and provide
+ * a validator that enforces email format rules.
+ *
+ * @example Extending with Zod validation
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createZodValidator } from '@cosmneo/onion-lasagna/backend/core/validators/zod';
+ *
+ * const emailSchema = z.string().email();
+ * const emailValidator = createZodValidator(emailSchema);
+ *
+ * class EmailVo extends BaseEmailVo {
+ *   static create(value: string): EmailVo {
+ *     return new EmailVo(value, emailValidator);
+ *   }
+ * }
+ * ```
+ *
+ * @example Usage
+ * ```typescript
+ * const email = EmailVo.create('user@example.com');
+ * console.log(email.value); // "user@example.com"
+ * ```
+ */
+
+/**
+ * Value object for email addresses.
+ *
+ * @extends BaseValueObject<string>
+ */
+declare class BaseEmailVo extends BaseValueObject<string> {
+    /**
+     * Creates a new BaseEmailVo instance.
+     *
+     * @param value - The email address string
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: string, validator: BoundValidator<string> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+}
+
+/**
+ * Base long text value object.
+ *
+ * Represents long-form text fields like articles, content bodies, or notes.
+ * Typically validated with a maximum length constraint (e.g., 5000+ chars).
+ *
+ * **Suggested Length:** 1-5000+ characters
+ *
+ * **Use Cases:**
+ * - Article content
+ * - Blog posts
+ * - Detailed notes
+ * - Rich text content
+ *
+ * @example Extending with length validation
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createZodValidator } from '@cosmneo/onion-lasagna/backend/core/validators/zod';
+ *
+ * const longTextSchema = z.string().min(1).max(10000);
+ * const longTextValidator = createZodValidator(longTextSchema);
+ *
+ * class ArticleContentVo extends BaseLongTextVo {
+ *   static create(value: string): ArticleContentVo {
+ *     return new ArticleContentVo(value, longTextValidator);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Value object for long-form text strings.
+ *
+ * @extends BaseValueObject<string>
+ */
+declare class BaseLongTextVo extends BaseValueObject<string> {
+    /**
+     * Creates a new BaseLongTextVo instance.
+     *
+     * @param value - The long text string
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: string, validator: BoundValidator<string> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+}
+
+/**
+ * Base medium text value object.
+ *
+ * Represents medium-length text fields like descriptions or summaries.
+ * Typically validated with a maximum length constraint (e.g., 500 chars).
+ *
+ * **Suggested Length:** 1-500 characters
+ *
+ * **Use Cases:**
+ * - Product descriptions
+ * - User bios
+ * - Short summaries
+ * - Comments
+ *
+ * @example Extending with length validation
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createZodValidator } from '@cosmneo/onion-lasagna/backend/core/validators/zod';
+ *
+ * const mediumTextSchema = z.string().min(1).max(500);
+ * const mediumTextValidator = createZodValidator(mediumTextSchema);
+ *
+ * class DescriptionVo extends BaseMediumTextVo {
+ *   static create(value: string): DescriptionVo {
+ *     return new DescriptionVo(value, mediumTextValidator);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Value object for medium-length text strings.
+ *
+ * @extends BaseValueObject<string>
+ */
+declare class BaseMediumTextVo extends BaseValueObject<string> {
+    /**
+     * Creates a new BaseMediumTextVo instance.
+     *
+     * @param value - The medium text string
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: string, validator: BoundValidator<string> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+}
+
+/**
+ * Base pagination value object.
+ *
+ * Represents pagination parameters for list queries. Validates that
+ * page numbers and page sizes are positive integers within bounds.
+ *
+ * **Properties:**
+ * - `page`: The current page number (typically 1-indexed)
+ * - `pageSize`: Number of items per page
+ *
+ * @example Extending with validation
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createZodValidator } from '@cosmneo/onion-lasagna/backend/core/validators/zod';
+ *
+ * const paginationSchema = z.object({
+ *   page: z.number().int().min(1),
+ *   pageSize: z.number().int().min(1).max(100),
+ * });
+ * const paginationValidator = createZodValidator(paginationSchema);
+ *
+ * class PaginationVo extends BasePaginationVo {
+ *   static create(page: number, pageSize: number): PaginationVo {
+ *     return new PaginationVo({ page, pageSize }, paginationValidator);
+ *   }
+ * }
+ * ```
+ *
+ * @example Usage in a use case
+ * ```typescript
+ * class ListUsersUseCase {
+ *   async execute(pagination: PaginationVo): Promise<User[]> {
+ *     const offset = (pagination.page - 1) * pagination.pageSize;
+ *     return this.userRepo.findAll({
+ *       offset,
+ *       limit: pagination.pageSize,
+ *     });
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Value object for pagination parameters.
+ *
+ * @extends BaseValueObject<{ page: number; pageSize: number }>
+ */
+declare class BasePaginationVo extends BaseValueObject<{
+    page: number;
+    pageSize: number;
+}> {
+    /**
+     * Creates a new BasePaginationVo instance.
+     *
+     * @param value - The pagination parameters
+     * @param value.page - The page number (typically 1-indexed)
+     * @param value.pageSize - The number of items per page
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: {
+        page: number;
+        pageSize: number;
+    }, validator: BoundValidator<{
+        page: number;
+        pageSize: number;
+    }> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+    /**
+     * The current page number.
+     */
+    get page(): number;
+    /**
+     * The number of items per page.
+     */
+    get pageSize(): number;
+}
+
+/**
+ * Base short text value object.
+ *
+ * Represents short text fields like names, titles, or labels.
+ * Typically validated with a maximum length constraint (e.g., 100 chars).
+ *
+ * **Suggested Length:** 1-100 characters
+ *
+ * **Use Cases:**
+ * - User names
+ * - Product titles
+ * - Category names
+ * - Short labels
+ *
+ * @example Extending with length validation
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createZodValidator } from '@cosmneo/onion-lasagna/backend/core/validators/zod';
+ *
+ * const shortTextSchema = z.string().min(1).max(100);
+ * const shortTextValidator = createZodValidator(shortTextSchema);
+ *
+ * class UserNameVo extends BaseShortTextVo {
+ *   static create(value: string): UserNameVo {
+ *     return new UserNameVo(value, shortTextValidator);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Value object for short text strings.
+ *
+ * @extends BaseValueObject<string>
+ */
+declare class BaseShortTextVo extends BaseValueObject<string> {
+    /**
+     * Creates a new BaseShortTextVo instance.
+     *
+     * @param value - The short text string
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: string, validator: BoundValidator<string> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+}
+
+/**
+ * Base UUID v7 value object for time-sortable entity identifiers.
+ *
+ * UUID v7 is a time-ordered UUID that combines a Unix timestamp with
+ * random bits, making it ideal for database primary keys because:
+ *
+ * **Benefits:**
+ * - **Time-sortable**: IDs created later sort after earlier ones
+ * - **Database-friendly**: Sequential nature reduces B-tree fragmentation
+ * - **Globally unique**: Same uniqueness guarantees as other UUID versions
+ * - **Timestamp extractable**: Creation time can be derived from the ID
+ *
+ * @example Generating a new ID
+ * ```typescript
+ * const id = BaseUuidV7Vo.generate();
+ * console.log(id.value); // e.g., "018f3b1c-5e7d-7000-8000-000000000001"
+ * ```
+ *
+ * @example Extending for validation
+ * ```typescript
+ * class EntityIdVo extends BaseUuidV7Vo {
+ *   static create(value: string): EntityIdVo {
+ *     return new EntityIdVo(value, uuidValidator);
+ *   }
+ *
+ *   static generate(): EntityIdVo {
+ *     return new EntityIdVo(v7(), SKIP_VALUE_OBJECT_VALIDATION);
+ *   }
+ * }
+ * ```
+ *
+ * @example Using as entity primary key
+ * ```typescript
+ * class User {
+ *   constructor(
+ *     public readonly id: EntityIdVo,
+ *     public readonly name: string,
+ *   ) {}
+ *
+ *   static create(name: string): User {
+ *     return new User(EntityIdVo.generate(), name);
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Value object for UUID v7 identifiers.
+ *
+ * Provides a `generate()` factory method that creates new time-ordered UUIDs.
+ *
+ * @extends BaseValueObject<string>
+ */
+declare class BaseUuidV7Vo extends BaseValueObject<string> {
+    /**
+     * Creates a new BaseUuidV7Vo instance.
+     *
+     * @param value - The UUID v7 string value
+     * @param validator - Bound validator or skip validation symbol
+     */
+    protected constructor(value: string, validator: BoundValidator<string> | typeof SKIP_VALUE_OBJECT_VALIDATION);
+    /**
+     * Generates a new UUID v7 value object.
+     *
+     * Creates a time-ordered UUID using the current timestamp,
+     * skipping validation since the `uuid` library guarantees format.
+     *
+     * @returns A new BaseUuidV7Vo with a freshly generated UUID
+     */
+    static generate(): BaseUuidV7Vo;
+    /**
+     * Creates a UUID v7 value object from an existing string.
+     *
+     * **Important:** This base implementation skips validation and accepts
+     * any string value. Subclasses should override this method with a
+     * validator to ensure UUID format correctness.
+     *
+     * @param value - The UUID v7 string value (not validated at base level)
+     * @returns A new BaseUuidV7Vo with the provided value
+     *
+     * @example Subclass with validation (recommended)
+     * ```typescript
+     * class OrderId extends BaseUuidV7Vo {
+     *   static override create(value: string): OrderId {
+     *     return new OrderId(value, uuidV7Validator);
+     *   }
+     * }
+     * ```
+     *
+     * @see generate - For creating new UUIDs (always valid)
+     */
+    static create(value: string): BaseUuidV7Vo;
+}
+
+export { BaseAuditByVo as B, SKIP_VALUE_OBJECT_VALIDATION as S, BaseUuidV4Vo as a, BaseAuditInfoVo as b, BaseAuditOnVo as c, BaseEmailVo as d, BaseLongTextVo as e, BaseMediumTextVo as f, BasePaginationVo as g, BaseShortTextVo as h, BaseUuidV7Vo as i, BaseValueObject as j, type SkipValueObjectValidation as k };