API Reference

Complete reference documentation for the Vyuh Entity System. This page provides quick-reference tables for all major classes, with links to detailed pages.

Core Classes

Class	Description
EntityBase	Abstract base class for all entities
EntityConfiguration	Unified configuration for an entity type
EntityApi	Abstract CRUD API for entities
EntitySystemPlugin	Plugin that registers entities and manages services
AuthorizationProvider	Synchronous authorization provider

Layout Classes

Class	Description
EntityLayouts	Container for all layout types
LayoutBase	Base class for all layout configurations
CollectionLayout	Layout for entity list views (tables, grids)
EntityLayout	Layout for single entity display (detail tabs, summary)
AggregateLayout	Layout for dashboards and analytics
EntityItemLayout	Single-entity snapshot rendering primitive
EntityComparisonLayout	Multi-entity side-by-side rendering primitive

Editor Classes

Class	Description
EntityEditor	Abstract base for entity editors
StandardEntityEditor	Non-regulated editor (no verification)
SignatureDrivenEditor	Regulated editor — resolves verification at runtime
EntityEditorPart	Abstract base for editor parts (tabs)
FormEditorPart	Built-in form-based editor part
CustomEditorPart	Callback-based custom editor part
EntityTransformer	Data transformation between entity and form
DefaultEntityTransformer	Pass-through transformer
SnakeCaseEntityTransformer	Auto camelCase ↔ snake_case transformer

Action Classes

Class	Description
EntityAction	Action on a single entity (inline, menu)
CollectionAction	Bulk or header action
ActionGroup	Dropdown grouping of EntityActions
EditorAction	Save/draft/cancel actions used by the editor
StandardEntityActions	Default Edit / Deactivate / Create helpers
VersionableActions	Defaults for entities mixing in Versionable

Service Classes

Class	Description
EntityService	Abstract base for all entity services
EntityServicesContainer	Type-safe service registry
QueryCacheService	Stale-while-revalidate query caching
EntityNameCacheService	Entity name/id cache
EntityLocalizationService	i18n for entity strings
EntityRealtimeService	Real-time entity update subscriptions
SignatureVerificationService	E-signature verification
EntityHelpService	Contextual help for entities
SearchSyncService	Search index synchronization
EntityDataExtractor	Search document extraction
ErrorDisplayService	UI error rendering

Permission / Authorization Classes

Class	Description
AuthorizationProvider	Abstract authorization interface (synchronous)
OpenAuthorizationProvider	Allow-all provider for dev
AuthorizeGuard	Widget that hides / disables UI by Authorize
AuthorizeFallback	Sealed class — what to show when denied
AuthorizeFallbackRegistry	Registry for custom fallback widgets
AuthorizationGate	App-shell gate tying the routed UI to provider lifecycle
EntityRoutePermissions	Route-level access control
EntityPermissionCache	Static cache for entity permission results

Data Types & Enums

Type	Description
FieldKey	Enum of standard entity field names (id, name, title, description, audit and version fields)
FieldKeyMap	Customizable mapping from FieldKey to JSON keys
EntitySelectionMode	How list selection is handled: none, navigate, responsive
EditorDisplayMode	Editor display: panel, fullWidth, adaptive
EditorActionType	Editor action style: save, draft, cancel
HttpMutationMethod	HTTP verb for HttpEntityApi.mutate: post, put, patch, delete
MutationType	Cache mutation kind: create, update, delete
EntityReference	Lightweight entity reference (id, name, description)
FieldDefinition<T>	Declarative field definition for columns and filters
ColumnPriority	essential / high / normal / low priority constants
UIVisibility	Sealed class — RouteVisibility, MenuVisibility, SearchVisibility, DashboardVisibility

Mixins

Mixin	Defined in	Description
Auditable	models/auditable.dart	createdAt, updatedAt, createdBy, updatedBy
HasCode	models/entity_mixins.dart	Entities with a code property
HasDescription	models/entity_mixins.dart	Entities with a description property
HasActiveStatus	models/entity_mixins.dart	Entities with an isActive property
HasStatus	models/entity_mixins.dart	Entities with a status property
Versionable	versioning_audit/models/versioned_entity.dart	Version tracking (versionNumber, isActive)
Draftable	drafts/draftable.dart	Draft support (draftMetadata, helper getters)

Quick Reference

EntityBase

abstract class EntityBase extends ContentItem {
  final String id;
  final String name;

  String get displayTitle;       // defaults to name
  String get displaySubtitle;    // defaults to ''
  Map<String, String> get displayProperties;  // defaults to {}

  Map<String, dynamic> toJson();
}

createdAt / updatedAt / createdBy / updatedBy come from the Auditable mixin. Versioning fields come from Versionable. Draft state comes from Draftable.

EntityConfiguration

final class EntityConfiguration<T extends EntityBase> {
  final EntityMetadata metadata;
  final EntityApi<T> api;
  final EntityLayouts<T> layouts;
  final EntityEditor<T>? editor;
  final EntityActions<T> actions;
  final EntityRouting routing;
  final List<FieldDefinition<T>>? fields;
  final List<FilterPreset>? filterPresets;
  final Map<String, String>? referenceFields;

  NavigationPathBuilder get route;
  List<RouteBase> buildRoutes();
  void register(EntitySystemPlugin plugin);
  EntityConfiguration<T> copyWith({...});
  static void clearAllPermissionCaches();
}

EntityApi

@immutable
abstract class EntityApi<T extends EntityBase> {
  final String entityType;
  final String schemaType;
  final String? defaultSortField;
  final bool hasDrafts;

  Future<T?> getOne(String id);
  Future<List<T>> getMany({...});
  Future<T> create(T entity, {String? remarks});
  Future<T> update(String id, T entity, {String? remarks});
  Future<bool> delete(String id);
  Future<int> count({String? query, Map<String, dynamic>? filters});
  Future<int?> findPosition(String entityId, {...});
  Future<List<T>> getDrafts({...});
  Future<int> countDrafts({String? query, Map<String, dynamic>? filters});
  T fromJson(Map<String, dynamic> json);
}

EntitySystemPlugin

class EntitySystemPlugin extends Plugin with RouteObservers {
  final String baseUrl;
  final AuthorizationProvider authorizationProvider;
  final SignatureVerificationProvider? signatureProvider;
  final FilterWidgetDelegate? filterWidgetDelegate;
  EntityServicesContainer get services;

  void register<T extends EntityBase>(EntityConfiguration<T> config);
  EntityConfiguration<T>? getConfig<T extends EntityBase>();
  EntityConfiguration<EntityBase>? getConfigByIdentifier(String identifier);
  bool isRegistered<T extends EntityBase>();
  List<RouteBase> generateRoutes();
  Future<void> registerService<T extends EntityService>(T service);
}

Detailed Pages

• EntityBase — Base class, mixins, FieldKey, entity reference
• EntityConfiguration — Configuration, metadata, routing, UIVisibility
• Actions — EntityAction, CollectionAction, ActionGroup, helpers
• EntityApi — CRUD API, HTTP implementation, caching, related APIs
• Layouts — Layout base, list, entity, aggregate, item, comparison
• Editors — Editor configuration, parts, transformers, lifecycle
• Permissions — AuthorizationProvider, AuthorizeGuard, route permissions
• Services — Plugin, service container, built-in services
• Glossary — Alphabetical index of all entity-system terms