@vidyano-labs/virtual-service 0.2.0 → 0.4.0

package/index.d.ts

@@ -1,10 +1,97 @@
-import { Dto, ServiceHooks, Service, Application } from '@vidyano/core';
+import { ServiceHooks, Dto, Service, Application } from '@vidyano/core';
+
+/**
+ * Virtual implementation of ServiceHooks for testing without a backend
+ */
+declare class VirtualServiceHooks extends ServiceHooks {
+    #private;
+    constructor();
+    /** @internal */
+    initialize(service: VirtualService): void;
+    /**
+     * Intercepts fetch requests and routes them to virtual handlers
+     */
+    onFetch(request: Request): Promise<Response>;
+}
+
+/**
+ * VirtualQueryColumn combines a QueryColumnDto with helper methods
+ */
+type VirtualQueryColumn = Dto.QueryColumnDto & {
+    /**
+     * Reference to config metadata (internal use)
+     */
+    readonly __configMeta?: {
+        canSort?: boolean;
+    };
+    /**
+     * Reference to the parent query
+     */
+    readonly query: VirtualQuery;
+    /**
+     * Reference to the VirtualService instance
+     */
+    readonly service: VirtualService;
+};
+/**
+ * VirtualQuery combines a QueryDto with helper methods
+ * This allows clean syntax for query manipulation while keeping the underlying DTO unchanged
+ */
+type VirtualQuery = Dto.QueryDto & {
+    /**
+     * Gets a column by name
+     */
+    getColumn(name: string): VirtualQueryColumn | undefined;
+    /**
+     * Sets a notification message on the query
+     */
+    setNotification(message: string, type: Dto.NotificationType, duration?: number): void;
+    /**
+     * Whether the query results should be included when loading the parent PersistentObject.
+     * Defaults to true for detail queries - set to false to skip pre-execution.
+     */
+    isIncludedInParentObject: boolean;
+    /**
+     * Reference to config (internal use)
+     */
+    readonly __config?: VirtualQueryConfig;
+    /**
+     * Reference to the VirtualService instance
+     */
+    readonly service: VirtualService;
+};
+/**
+ * VirtualQueryResultItem combines a QueryResultItemDto with helper methods
+ */
+type VirtualQueryResultItem = Dto.QueryResultItemDto & {
+    /**
+     * Gets a value from the item by column name
+     */
+    getValue(columnName: string): any;
+    /**
+     * Reference to the parent query
+     */
+    readonly query: VirtualQuery;
+    /**
+     * Reference to the VirtualService instance
+     */
+    readonly service: VirtualService;
+};
 
 /**
  * VirtualPersistentObjectAttribute combines a PersistentObjectAttributeDto with helper methods
  * This allows clean syntax like attr.getValue() and attr.setValue() while keeping the underlying DTO unchanged
  */
-type VirtualPersistentObjectAttribute = Dto.PersistentObjectAttributeDto & {
+type VirtualPersistentObjectAttribute = Dto.PersistentObjectAttributeDto & VirtualPersistentObjectAttributeHelpers;
+/**
+ * VirtualPersistentObjectAttributeWithReference extends VirtualPersistentObjectAttribute with reference-specific properties
+ * Use this type when the attribute type is "Reference"
+ */
+type VirtualPersistentObjectAttributeWithReference = Dto.PersistentObjectAttributeWithReferenceDto & VirtualPersistentObjectAttributeHelpers;
+/**
+ * Helper methods added to VirtualPersistentObjectAttribute
+ */
+type VirtualPersistentObjectAttributeHelpers = {
     /**
      * Gets the converted value of this attribute (e.g., Boolean as boolean, Int32 as number)
      */
@@ -14,19 +101,23 @@ type VirtualPersistentObjectAttribute = Dto.PersistentObjectAttributeDto & {
      */
     setValue(value: any): void;
     /**
-     * Sets a validation error on this attribute
+     * Sets a validation error on this attribute. Pass null/empty to clear.
+     */
+    setValidationError(error: string | null | undefined): void;
+    /**
+     * Reference to the parent persistent object
      */
-    setValidationError(error: string): void;
+    readonly persistentObject: VirtualPersistentObject;
     /**
-     * Clears the validation error on this attribute
+     * Reference to the VirtualService instance
      */
-    clearValidationError(): void;
+    readonly service: VirtualService;
 };
 /**
  * VirtualPersistentObject combines a PersistentObjectDto with helper methods
  * This allows clean syntax like obj.setAttributeValue() while keeping the underlying DTO unchanged
  */
-type VirtualPersistentObject = Dto.PersistentObjectDto & {
+type VirtualPersistentObject = Omit<Dto.PersistentObjectDto, "queries"> & {
     /**
      * Gets an attribute by name, wrapped with getValue/setValue methods
      */
@@ -40,17 +131,17 @@ type VirtualPersistentObject = Dto.PersistentObjectDto & {
      */
     setAttributeValue(name: string, value: any): void;
     /**
-     * Sets a validation error for an attribute
+     * Sets a notification message on the persistent object
      */
-    setValidationError(name: string, error: string): void;
+    setNotification(message: string, type: Dto.NotificationType, duration?: number): void;
     /**
-     * Clears a validation error for an attribute
+     * Detail queries attached to this persistent object, wrapped as VirtualQuery
      */
-    clearValidationError(name: string): void;
+    queries?: VirtualQuery[];
     /**
-     * Sets a notification message on the persistent object
+     * Reference to the VirtualService instance
      */
-    setNotification(message: string, type: Dto.NotificationType, duration?: number): void;
+    readonly service: VirtualService;
 };
 
 /**
@@ -152,29 +243,25 @@ type ActionArgs = {
      * For PersistentObject actions: the PersistentObject itself
      * For Query actions: the parent PO that owns the query, or null for top-level queries
      */
-    parent: Dto.PersistentObjectDto | null;
+    parent: VirtualPersistentObject | null;
     /**
      * The query context (like args.Query in C#) - present if action invoked from query
      */
-    query?: Dto.QueryDto;
+    query?: VirtualQuery;
     /**
      * Selected items (like args.SelectedItems in C#) - present if query action with selections
      */
-    selectedItems?: Dto.QueryResultItemDto[];
+    selectedItems?: VirtualQueryResultItem[];
     /**
      * Additional parameters (like args.Parameters in C#)
      */
     parameters?: Record<string, any>;
-    /**
-     * Helper context for modifying attributes and setting notifications
-     */
-    context: ActionContext;
 };
 /**
  * Unified action handler (matches C# CustomAction Execute signature)
  * Return the PersistentObject to refresh UI, or null to complete silently
  */
-type ActionHandler = (args: ActionArgs) => Promise<Dto.PersistentObjectDto | null> | Dto.PersistentObjectDto | null;
+type ActionHandler = (args: ActionArgs) => Promise<VirtualPersistentObject | null> | VirtualPersistentObject | null;
 /**
  * Action configuration
  */
@@ -191,60 +278,6 @@ type ActionConfig = {
      * Indicates whether the action is pinned. Defaults to false.
      */
     isPinned?: boolean;
-    /**
-     * Custom action logic handler.
-     */
-    handler: ActionHandler;
-};
-/**
- * Context provides safe API to modify the persistent object during actions
- */
-type ActionContext = {
-    /**
-     * Gets an attribute by name.
-     */
-    getAttribute: (name: string) => Dto.PersistentObjectAttributeDto | undefined;
-    /**
-     * Gets the value of an attribute by name.
-     */
-    getAttributeValue: (name: string) => any;
-    /**
-     * Sets the value of an attribute by name.
-     */
-    setAttributeValue: (name: string, value: any) => void;
-    /**
-     * Gets the converted value of an attribute DTO (e.g., Boolean as boolean, Int32 as number).
-     */
-    getConvertedValue: (attr: Dto.PersistentObjectAttributeDto) => any;
-    /**
-     * Sets the value on an attribute DTO with automatic type conversion.
-     */
-    setConvertedValue: (attr: Dto.PersistentObjectAttributeDto, value: any) => void;
-    /**
-     * Sets a validation error for an attribute.
-     */
-    setValidationError: (name: string, error: string) => void;
-    /**
-     * Clears the validation error for an attribute.
-     */
-    clearValidationError: (name: string) => void;
-    /**
-     * Sets a notification message.
-     */
-    setNotification: (message: string, type: Dto.NotificationType, duration?: number) => void;
-};
-/**
- * Context provided to business rule validators for accessing the persistent object
- */
-type RuleValidationContext = {
-    /**
-     * The persistent object being validated (wrapped with helper methods)
-     */
-    persistentObject: VirtualPersistentObject;
-    /**
-     * The attribute being validated (wrapped with helper methods)
-     */
-    attribute: VirtualPersistentObjectAttribute;
 };
 /**
  * PersistentObject configuration - converted to PersistentObjectDto
@@ -345,17 +378,85 @@ type VirtualQueryConfig = {
     pageSize?: number;
 };
 
+/**
+ * Parsed business rule with name and parameters
+ * @internal
+ */
+type ParsedRule = {
+    name: string;
+    params: any[];
+};
 /**
  * Rule validator function that throws an error if invalid, or returns nothing if valid
+ * @param value - The converted attribute value
+ * @param attribute - The wrapped attribute with access to persistentObject and service
+ * @param params - Additional parameters from the rule definition
+ * @internal - Exported for internal package use only, not re-exported from index.ts
+ */
+type RuleValidatorFn = (value: any, attribute: VirtualPersistentObjectAttribute, ...params: any[]) => void;
+/**
+ * Business rule validator that supports built-in and custom rules
  */
-type RuleValidatorFn = (value: any, context: RuleValidationContext, ...params: any[]) => void;
+declare class BusinessRuleValidator {
+    #private;
+    /**
+     * Checks if a rules string contains NotEmpty or Required rule
+     * @param rules - The rules string (semicolon-separated)
+     * @returns true if rules contain NotEmpty or Required
+     */
+    static hasRequiredRule(rules?: string): boolean;
+    constructor(service: VirtualService);
+    /**
+     * Register a custom business rule
+     * @throws Error if attempting to override a built-in rule
+     */
+    registerCustomRule(name: string, validator: RuleValidatorFn): void;
+    /**
+     * Validate an attribute against its rules
+     * @param attr - The wrapped attribute to validate (has getValue/setValue methods and persistentObject reference)
+     * @param _po - Deprecated: The persistent object is now accessible via attr.persistentObject
+     * @returns Error message if validation fails, null if valid
+     */
+    validateAttribute(attr: VirtualPersistentObjectAttribute, _po: VirtualPersistentObject): string | null;
+    /**
+     * Parse a rules string into individual rules with parameters
+     * Example: "NotEmpty; MaxLength(40); IsEmail" -> [
+     *   { name: "NotEmpty", params: [] },
+     *   { name: "MaxLength", params: [40] },
+     *   { name: "IsEmail", params: [] }
+     * ]
+     */
+    parseRules(rulesString: string): ParsedRule[];
+}
 
+/**
+ * @internal
+ */
+declare const initializeActions: unique symbol;
 /**
  * Base class for PersistentObject lifecycle methods
  * Extend this class to override lifecycle hooks like onLoad, onSave, onRefresh, etc.
  * All methods have default implementations, so you only need to override what you need.
  */
 declare class VirtualPersistentObjectActions {
+    #private;
+    /**
+     * Validator instance for business rule validation (injected by registry)
+     */
+    protected validator?: BusinessRuleValidator;
+    /**
+     * VirtualService instance for message translation (injected by registry)
+     */
+    protected service?: VirtualService;
+    /**
+     * The PersistentObject type name (injected by registry during instance creation)
+     */
+    protected type?: string;
+    /**
+     * Internal initialization method (called by registry during instance creation)
+     * @internal
+     */
+    [initializeActions](validator: BusinessRuleValidator, service: VirtualService, type?: string): void;
     /**
      * Called every time a PersistentObject DTO is created (both new and existing objects)
      * Use this to set metadata on attributes that can only be known at runtime
@@ -363,23 +464,28 @@ declare class VirtualPersistentObjectActions {
      */
     onConstruct(obj: VirtualPersistentObject): void;
     /**
-     * Called when loading an existing PersistentObject by ID
-     * Use this to load entity data and populate attribute values
-     * @param obj - The constructed PersistentObject DTO (after onConstruct)
+     * Called when loading an existing object.
+     * @param objectId - The ID of the object to load
      * @param parent - The parent PersistentObject if loaded in a master-detail context, null otherwise
      * @returns The PersistentObject with loaded data
      */
-    onLoad(obj: VirtualPersistentObject, parent: VirtualPersistentObject | null): Promise<VirtualPersistentObject>;
+    onLoad(objectId: string, parent: VirtualPersistentObject | null): Promise<VirtualPersistentObject>;
     /**
-     * Called when creating a new PersistentObject via the "New" action
-     * Use this to create a fresh entity instance with default values
-     * @param obj - The constructed PersistentObject DTO (after onConstruct)
+     * Called when creating a new object.
      * @param parent - The parent PersistentObject if creating from a detail query, null otherwise
      * @param query - The Query from which the New action was invoked, null if not from a query
      * @param parameters - Optional parameters including "MenuOption" if NewOptions exist
      * @returns The PersistentObject with default values set
      */
-    onNew(obj: VirtualPersistentObject, parent: VirtualPersistentObject | null, query: Dto.QueryDto | null, parameters: Record<string, string> | null): Promise<VirtualPersistentObject>;
+    onNew(parent: VirtualPersistentObject | null, query: VirtualQuery | null, parameters: Record<string, string> | null): Promise<VirtualPersistentObject>;
+    /**
+     * Full query lifecycle - builds query, calls onConstructQuery, auto-executes if configured
+     * Override this to customize how queries are retrieved
+     * @param queryName - The name of the query to get
+     * @param parent - The parent PersistentObject if this is a detail query, null otherwise
+     * @returns The Query with results if autoQuery is enabled
+     */
+    onGetQuery(queryName: string, parent: VirtualPersistentObject | null): Promise<VirtualQuery>;
     /**
      * Called when an attribute with triggersRefresh: true is changed
      * Use this to update other attributes based on the changed attribute
@@ -395,6 +501,13 @@ declare class VirtualPersistentObjectActions {
      * @returns The saved PersistentObject
      */
     onSave(obj: VirtualPersistentObject): Promise<VirtualPersistentObject>;
+    /**
+     * Validates all attributes against their business rules
+     * Override this to customize validation behavior
+     * @param obj - The wrapped PersistentObject to validate (already has config metadata merged)
+     * @returns true if all rules pass, false if any validation errors
+     */
+    checkRules(obj: VirtualPersistentObject): boolean;
     /**
      * Called by onSave when obj.isNew === true
      * Use this to save a new entity to the data store
@@ -418,7 +531,7 @@ declare class VirtualPersistentObjectActions {
      * @param query - The query that was used to select the reference
      * @param selectedItem - The QueryResultItem that was selected, or null if reference was cleared
      */
-    onSelectReference(_parent: VirtualPersistentObject, referenceAttribute: Dto.PersistentObjectAttributeDto, _query: Dto.QueryDto, selectedItem: Dto.QueryResultItemDto | null): Promise<void>;
+    onSelectReference(_parent: VirtualPersistentObject, referenceAttribute: VirtualPersistentObjectAttribute, _query: VirtualQuery, selectedItem: VirtualQueryResultItem | null): Promise<void>;
     /**
      * Called when the Delete action is executed on selected items in a Query
      * Use this to handle deletion of entities
@@ -426,14 +539,14 @@ declare class VirtualPersistentObjectActions {
      * @param query - The query from which items are being deleted
      * @param selectedItems - The QueryResultItems that are selected for deletion
      */
-    onDelete(parent: VirtualPersistentObject | null, query: Dto.QueryDto, selectedItems: Dto.QueryResultItemDto[]): Promise<void>;
+    onDelete(parent: VirtualPersistentObject | null, query: VirtualQuery, selectedItems: VirtualQueryResultItem[]): Promise<void>;
     /**
      * Called when a Query of this PersistentObject type is constructed
      * Use this to set metadata on query columns that can only be known at runtime
      * @param query - The Query DTO being constructed
      * @param parent - The parent PersistentObject if this is a detail query, null for top-level queries
      */
-    onConstructQuery(query: Dto.QueryDto, parent: VirtualPersistentObject | null): void;
+    onConstructQuery(query: VirtualQuery, parent: VirtualPersistentObject | null): void;
     /**
      * Called when a Query is executed.
      * The base implementation calls getEntities() and applies text search, sorting, and pagination.
@@ -442,7 +555,7 @@ declare class VirtualPersistentObjectActions {
      * @param data - Default data from the query config (used if getEntities is not overridden)
      * @returns The items matching the query criteria and the total count before pagination
      */
-    onExecuteQuery(query: Dto.QueryDto, parent: VirtualPersistentObject | null, data: Record<string, any>[]): Promise<VirtualQueryExecuteResult>;
+    onExecuteQuery(query: VirtualQuery, parent: VirtualPersistentObject | null, data: Record<string, any>[]): Promise<VirtualQueryExecuteResult>;
     /**
      * Override this to provide the full list of items for a query.
      * The base onExecuteQuery will handle text search, sorting, and pagination automatically.
@@ -451,44 +564,140 @@ declare class VirtualPersistentObjectActions {
      * @param data - Default data from the query config
      * @returns All items matching the query criteria (before pagination)
      */
-    getEntities(_query: Dto.QueryDto, _parent: VirtualPersistentObject | null, data: Record<string, any>[]): Promise<Record<string, any>[]>;
+    getEntities(_query: VirtualQuery, _parent: VirtualPersistentObject | null, data: Record<string, any>[]): Promise<Record<string, any>[]>;
+    /**
+     * Builds a PersistentObject from configuration
+     * @param objectId - The object ID
+     * @param isNew - Whether this is a new object
+     * @returns The wrapped VirtualPersistentObject
+     */
+    protected buildPersistentObject(objectId: string, isNew: boolean): Promise<VirtualPersistentObject>;
+    /**
+     * Builds a Query from configuration
+     * @param name - The query name
+     * @returns The wrapped VirtualQuery
+     */
+    protected buildQuery(name: string): Promise<VirtualQuery>;
+    /**
+     * Executes queries that have isIncludedInParentObject set (defaults to true).
+     * Called automatically after onLoad/onNew completes.
+     * @param obj - The PersistentObject to execute queries for
+     */
+    executeIncludedQueries(obj: VirtualPersistentObject): Promise<void>;
+    /**
+     * Gets the default data for a query from configuration
+     * @param name - The query name
+     * @returns The default data array
+     */
+    protected getQueryData(name: string): Record<string, any>[];
 }
 
+/** Lifecycle methods that can be overridden in VirtualPersistentObjectActions */
+type LifecycleMethod = "onSave" | "onNew" | "onDelete" | "onRefresh" | "onLoad" | "onConstruct" | "onConstructQuery" | "onSelectReference" | "onExecuteQuery" | "getEntities";
 /**
- * Virtual implementation of ServiceHooks for testing without a backend
+ * Registry for managing VirtualPersistentObjectActions classes
+ * Provides methods to register actions classes and create instances
  */
-declare class VirtualServiceHooks extends ServiceHooks {
+declare class VirtualPersistentObjectActionsRegistry {
     #private;
-    constructor();
+    constructor(validator: BusinessRuleValidator, service: VirtualService);
     /**
-     * Intercepts fetch requests and routes them to virtual handlers
+     * Registers a VirtualPersistentObjectActions class for a specific type
+     * @param type - The PersistentObject type name
+     * @param ActionsClass - The VirtualPersistentObjectActions class constructor
      */
-    onFetch(request: Request): Promise<Response>;
+    register(type: string, ActionsClass: typeof VirtualPersistentObjectActions): void;
+    /**
+     * Checks if a specific lifecycle method is overridden for a type
+     * @param type - The PersistentObject type name
+     * @param methodName - The lifecycle method name
+     * @returns true if the method is overridden, false otherwise
+     */
+    isMethodOverridden(type: string, methodName: LifecycleMethod): boolean;
+    /**
+     * Checks if a type has registered actions
+     * @param type - The PersistentObject type name
+     * @returns true if the type has registered actions, false otherwise
+     */
+    has(type: string): boolean;
+    /**
+     * Creates a new instance of the actions class for a type
+     * Returns a default VirtualPersistentObjectActions if no custom actions are registered
+     * Injects validator, service, and type into the instance
+     * @param type - The PersistentObject type name
+     * @returns A new instance of the VirtualPersistentObjectActions class
+     */
+    createInstance(type: string): VirtualPersistentObjectActions;
+}
+
+/**
+ * Registry for managing PersistentObject configurations (pure config store)
+ */
+declare class VirtualPersistentObjectRegistry {
+    #private;
     /**
      * Registers a PersistentObject configuration
      */
-    registerPersistentObject(config: VirtualPersistentObjectConfig): void;
+    register(config: VirtualPersistentObjectConfig): void;
     /**
-     * Registers a Query configuration
+     * Gets a registered PersistentObject configuration
      */
-    registerQuery(config: VirtualQueryConfig): void;
+    getConfig(type: string): VirtualPersistentObjectConfig | undefined;
     /**
-     * Registers a custom action that can be used on PersistentObjects and Queries
-     * @param config - The action configuration with handler
+     * Checks if a type has a registered configuration
      */
-    registerAction(config: ActionConfig): void;
+    hasConfig(type: string): boolean;
+}
+
+/**
+ * Registry for managing Query configurations (config + columns store)
+ */
+declare class VirtualQueryRegistry {
+    #private;
     /**
-     * Registers a custom business rule for validation
-     * @param name - The rule name (cannot override built-in rules)
-     * @param validator - The validation function
+     * Checks if a query is registered
+     * @param name - The query name
      */
-    registerBusinessRule(name: string, validator: RuleValidatorFn): void;
+    hasQuery(name: string): boolean;
     /**
-     * Registers a VirtualPersistentObjectActions class for a specific type
-     * @param type - The PersistentObject type name
-     * @param ActionsClass - The VirtualPersistentObjectActions class constructor
+     * Gets a registered Query configuration
+     * @param name - The query name
+     */
+    getQueryConfig(name: string): VirtualQueryConfig | undefined;
+    /**
+     * Gets the PersistentObject configuration for a query
+     * @param name - The query name
+     */
+    getPersistentObjectConfig(name: string): VirtualPersistentObjectConfig | undefined;
+    /**
+     * Gets the columns for a query
+     * @param name - The query name
+     */
+    getColumns(name: string): Dto.QueryColumnDto[];
+    /**
+     * Gets the default data for a query
+     * @param name - The query name
+     */
+    getData(name: string): Record<string, any>[];
+    /**
+     * Registers a Query configuration
+     */
+    register(config: VirtualQueryConfig, persistentObjectConfig: VirtualPersistentObjectConfig): void;
+    /**
+     * Builds a QueryResultDto from execution result
+     * @param result - The query execution result with items and totalItems
+     * @param columns - The query columns
+     * @param pageSize - The page size
+     * @returns The QueryResultDto
      */
-    registerPersistentObjectActions(type: string, ActionsClass: typeof VirtualPersistentObjectActions): void;
+    static buildQueryResultDto(result: VirtualQueryExecuteResult, columns: Dto.QueryColumnDto[], pageSize: number): Dto.QueryResultDto;
+    /**
+     * Builds a QueryResultItemDto from a data row
+     * @param data - The data row
+     * @param columns - The query columns
+     * @returns The QueryResultItemDto
+     */
+    static buildQueryResultItemDto(data: Record<string, any>, columns: Dto.QueryColumnDto[]): Dto.QueryResultItemDto;
 }
 
 /**
@@ -511,27 +720,69 @@ declare class VirtualServiceHooks extends ServiceHooks {
 declare class VirtualService extends Service {
     #private;
     /**
-     * Creates a new VirtualService instance.
-     * @param hooks - Optional custom VirtualServiceHooks. If not provided, a default instance is created.
+     * Gets a copy of the global messages dictionary.
      */
-    constructor(hooks?: VirtualServiceHooks);
+    static get messages(): Record<string, string>;
+    /**
+     * Sets the global messages dictionary.
+     * Use this to provide translations or override default messages.
+     * @example
+     * VirtualService.messages = {
+     *     "Required": "Dit veld is verplicht",
+     *     "MaxLength": "Maximale lengte is {0} tekens"
+     * };
+     */
+    static set messages(value: Record<string, string>);
     /**
-     * Gets the VirtualServiceHooks instance.
+     * Converts a service string value to a primitive JavaScript type.
+     * Unlike DataType.fromServiceString, this returns number instead of BigNumber
+     * for numeric types (Decimal, Double, Int64, etc.).
      */
-    get virtualHooks(): VirtualServiceHooks;
+    static fromServiceValue(value: any, type: string): any;
+    /**
+     * Converts a primitive JavaScript value to a service string.
+     */
+    static toServiceValue(value: any, type: string): string;
+    /**
+     * Gets a message by key with optional parameters.
+     * Resolution: static messages → return key unchanged
+     * @param key - The message key (e.g., "Required", "MaxLength")
+     * @param params - Positional parameters for {0}, {1} placeholders
+     * @returns The formatted message, or the key if not found
+     */
+    getMessage(key: string, ...params: any[]): string;
+    /**
+     * Creates a new VirtualService instance.
+     * @param hooks - Optional custom hooks instance.
+     */
+    constructor(hooks?: VirtualServiceHooks);
+    /** @internal */
+    get persistentObjectRegistry(): VirtualPersistentObjectRegistry;
+    /** @internal */
+    get queryRegistry(): VirtualQueryRegistry;
+    /** @internal */
+    get actionsRegistry(): VirtualPersistentObjectActionsRegistry;
+    /** @internal */
+    get _actionDefinitions(): Map<string, {
+        name: string;
+        displayName: string;
+        isPinned: boolean;
+    }>;
+    /** @internal */
+    get actionHandlers(): Map<string, ActionHandler>;
     /**
      * Initializes the service and finalizes all registrations.
      * After this method is called, no more registrations are allowed.
      */
-    initialize(skipDefaultCredentialLogin?: boolean): Promise<Application>;
-    initialize(oneTimeSignInToken: string): Promise<Application>;
+    initialize(): Promise<Application>;
     /**
      * Registers a PersistentObject configuration.
      * Must be called before initialize().
      * @param config - The PersistentObject configuration.
+     * @param lifecycle - Optional lifecycle class for hooks (onLoad, onSave, onNew, etc.).
      * @throws Error if called after initialize().
      */
-    registerPersistentObject(config: VirtualPersistentObjectConfig): void;
+    registerPersistentObject(config: VirtualPersistentObjectConfig, lifecycle?: typeof VirtualPersistentObjectActions): void;
     /**
      * Registers a Query configuration.
      * Must be called before initialize().
@@ -542,27 +793,28 @@ declare class VirtualService extends Service {
     /**
      * Registers a custom action that can be used on PersistentObjects and Queries.
      * Must be called before initialize().
-     * @param config - The action configuration with handler.
+     * @param name - The action name.
+     * @param handler - The action handler function.
      * @throws Error if called after initialize().
      */
-    registerAction(config: ActionConfig): void;
+    registerCustomAction(name: string, handler: ActionHandler): void;
     /**
-     * Registers a custom business rule for validation.
+     * Registers a custom action that can be used on PersistentObjects and Queries.
      * Must be called before initialize().
-     * @param name - The rule name (cannot override built-in rules).
-     * @param validator - The validation function.
+     * @param config - The action configuration.
+     * @param handler - The action handler function.
      * @throws Error if called after initialize().
      */
-    registerBusinessRule(name: string, validator: RuleValidatorFn): void;
+    registerCustomAction(config: ActionConfig, handler: ActionHandler): void;
     /**
-     * Registers a VirtualPersistentObjectActions class for a specific type.
+     * Registers a custom business rule for validation.
      * Must be called before initialize().
-     * @param type - The PersistentObject type name.
-     * @param ActionsClass - The VirtualPersistentObjectActions class constructor.
+     * @param name - The rule name (cannot override built-in rules).
+     * @param validator - The validation function.
      * @throws Error if called after initialize().
      */
-    registerPersistentObjectActions(type: string, ActionsClass: typeof VirtualPersistentObjectActions): void;
+    registerBusinessRule(name: string, validator: RuleValidatorFn): void;
 }
 
 export { VirtualPersistentObjectActions, VirtualService, VirtualServiceHooks };
-export type { ActionArgs, ActionConfig, ActionContext, ActionHandler, RuleValidationContext, RuleValidatorFn, VirtualPersistentObject, VirtualPersistentObjectAttribute, VirtualPersistentObjectAttributeConfig, VirtualPersistentObjectConfig, VirtualQueryConfig, VirtualQueryExecuteResult };
+export type { VirtualPersistentObject, VirtualPersistentObjectAttribute, VirtualPersistentObjectAttributeConfig, VirtualPersistentObjectAttributeWithReference, VirtualPersistentObjectConfig, VirtualQuery, VirtualQueryConfig, VirtualQueryExecuteResult, VirtualQueryResultItem };