@mintplayer/ng-spark 0.1.2 → 0.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mintplayer/ng-spark",
   "private": false,
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Angular component library for MintPlayer.Spark CRUD applications",
   "repository": {
     "type": "git",
@@ -27,6 +27,54 @@
     ".": {
       "types": "./types/mintplayer-ng-spark.d.ts",
       "default": "./fesm2022/mintplayer-ng-spark.mjs"
+    },
+    "./icon": {
+      "types": "./types/mintplayer-ng-spark-icon.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-icon.mjs"
+    },
+    "./models": {
+      "types": "./types/mintplayer-ng-spark-models.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-models.mjs"
+    },
+    "./pipes": {
+      "types": "./types/mintplayer-ng-spark-pipes.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-pipes.mjs"
+    },
+    "./po-create": {
+      "types": "./types/mintplayer-ng-spark-po-create.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-po-create.mjs"
+    },
+    "./po-detail": {
+      "types": "./types/mintplayer-ng-spark-po-detail.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-po-detail.mjs"
+    },
+    "./po-edit": {
+      "types": "./types/mintplayer-ng-spark-po-edit.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-po-edit.mjs"
+    },
+    "./po-form": {
+      "types": "./types/mintplayer-ng-spark-po-form.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-po-form.mjs"
+    },
+    "./query-list": {
+      "types": "./types/mintplayer-ng-spark-query-list.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-query-list.mjs"
+    },
+    "./renderers": {
+      "types": "./types/mintplayer-ng-spark-renderers.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-renderers.mjs"
+    },
+    "./retry-action-modal": {
+      "types": "./types/mintplayer-ng-spark-retry-action-modal.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-retry-action-modal.mjs"
+    },
+    "./routes": {
+      "types": "./types/mintplayer-ng-spark-routes.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-routes.mjs"
+    },
+    "./services": {
+      "types": "./types/mintplayer-ng-spark-services.d.ts",
+      "default": "./fesm2022/mintplayer-ng-spark-services.mjs"
     }
   },
   "dependencies": {

package/types/mintplayer-ng-spark-icon.d.ts

@@ -0,0 +1,13 @@
+import * as _angular_platform_browser from '@angular/platform-browser';
+import * as _angular_core from '@angular/core';
+
+declare class SparkIconComponent {
+    private registry;
+    name: _angular_core.InputSignal<string>;
+    iconHtml: _angular_core.Signal<_angular_platform_browser.SafeHtml>;
+    cssFallbackClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkIconComponent, "spark-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SparkIconComponent };

package/types/mintplayer-ng-spark-models.d.ts

@@ -0,0 +1,275 @@
+import { WritableSignal } from '@angular/core';
+
+type TranslatedString = Record<string, string>;
+/** Global reactive language state — shared across library boundaries via globalThis */
+declare const currentLanguage: WritableSignal<string>;
+declare function resolveTranslation(ts: TranslatedString | undefined, lang?: string): string;
+
+interface ValidationRule {
+    type: string;
+    value?: any;
+    min?: number;
+    max?: number;
+    message?: TranslatedString;
+}
+
+interface ValidationError {
+    attributeName: string;
+    errorMessage: TranslatedString;
+    ruleType: string;
+}
+interface ValidationErrorResponse {
+    errors: ValidationError[];
+}
+
+/**
+ * Flags enum controlling on which pages an attribute should be displayed.
+ * Values can be combined: ShowedOn.Query | ShowedOn.PersistentObject
+ */
+declare enum ShowedOn {
+    Query = 1,
+    PersistentObject = 2
+}
+/**
+ * Helper function to check if a ShowedOn value includes a specific flag.
+ */
+declare function hasShowedOnFlag(value: ShowedOn | string | undefined, flag: ShowedOn): boolean;
+
+interface PersistentObjectAttribute {
+    id: string;
+    name: string;
+    label?: TranslatedString;
+    value?: any;
+    dataType: string;
+    isArray?: boolean;
+    isRequired: boolean;
+    isVisible: boolean;
+    isReadOnly: boolean;
+    order: number;
+    query?: string;
+    breadcrumb?: string;
+    /**
+     * Controls on which pages the attribute should be displayed.
+     * Query = shown in list views, PersistentObject = shown in detail/edit views.
+     * Can be a numeric flag value or a string like "Query, PersistentObject".
+     */
+    showedOn?: ShowedOn | string;
+    isValueChanged?: boolean;
+    rules: ValidationRule[];
+    group?: string;
+    /** Renderer component name for custom display in detail/list views */
+    renderer?: string;
+    /** Options passed to the renderer component */
+    rendererOptions?: Record<string, any>;
+}
+
+interface PersistentObject {
+    id: string;
+    name: string;
+    objectTypeId: string;
+    breadcrumb?: string;
+    attributes: PersistentObjectAttribute[];
+}
+
+interface EntityAttributeDefinition {
+    id: string;
+    name: string;
+    label?: TranslatedString;
+    dataType: string;
+    isRequired: boolean;
+    isVisible: boolean;
+    isReadOnly: boolean;
+    order: number;
+    query?: string;
+    /** For reference attributes, specifies the target entity type's CLR type name */
+    referenceType?: string;
+    /** For AsDetail attributes, specifies the nested entity type's CLR type name */
+    asDetailType?: string;
+    /** When true, the attribute represents an array/collection of AsDetail objects */
+    isArray?: boolean;
+    /** For array AsDetail attributes: "modal" (default) or "inline" */
+    editMode?: 'inline' | 'modal';
+    /** For LookupReference attributes, specifies the lookup reference type name */
+    lookupReferenceType?: string;
+    /**
+     * Controls on which pages the attribute should be displayed.
+     * Query = shown in list views, PersistentObject = shown in detail/edit views.
+     * Can be a numeric flag value or a string like "Query, PersistentObject".
+     */
+    showedOn?: ShowedOn | string;
+    rules: ValidationRule[];
+    /** References an AttributeGroup.id to assign this attribute to a group */
+    group?: string;
+    /** Number of grid columns this attribute spans within a tab's column layout */
+    columnSpan?: number;
+    /** Renderer component name for custom display in detail/list views */
+    renderer?: string;
+    /** Options passed to the renderer component */
+    rendererOptions?: Record<string, any>;
+}
+interface AttributeTab {
+    id: string;
+    name: string;
+    label?: TranslatedString;
+    order: number;
+    /** Number of columns for the grid layout within this tab */
+    columnCount?: number;
+}
+interface AttributeGroup {
+    id: string;
+    name: string;
+    label?: TranslatedString;
+    /** References an AttributeTab.id to assign this group to a tab */
+    tab?: string;
+    order: number;
+}
+interface EntityType {
+    id: string;
+    name: string;
+    description?: TranslatedString;
+    clrType: string;
+    alias?: string;
+    /**
+     * Template string with {PropertyName} placeholders for building a formatted display value.
+     * Example: "{Street}, {PostalCode} {City}"
+     */
+    displayFormat?: string;
+    /**
+     * (Fallback) Single attribute name to use as display value when displayFormat is not specified.
+     */
+    displayAttribute?: string;
+    tabs?: AttributeTab[];
+    groups?: AttributeGroup[];
+    attributes: EntityAttributeDefinition[];
+    /** Query aliases or IDs to display as related query tables on the detail page. */
+    queries?: string[];
+}
+
+type SparkQueryRenderMode = 'Pagination' | 'VirtualScrolling';
+interface SparkQuerySortColumn {
+    property: string;
+    direction: string;
+}
+interface SparkQuery {
+    id: string;
+    name: string;
+    description?: TranslatedString;
+    source: string;
+    alias?: string;
+    sortColumns: SparkQuerySortColumn[];
+    renderMode?: SparkQueryRenderMode;
+    /** Optional RavenDB index name for queries using indexes */
+    indexName?: string;
+    /** When true, uses the projection type from [QueryType] attribute */
+    useProjection?: boolean;
+    /** Optional entity type name (e.g., "Person"). When set, used for entity type resolution. */
+    entityType?: string;
+    /** When true, this query uses WebSocket streaming with snapshot + patch updates. */
+    isStreamingQuery?: boolean;
+}
+
+interface QueryResult {
+    data: PersistentObject[];
+    totalRecords: number;
+    skip: number;
+    take: number;
+}
+
+interface ProgramUnit {
+    id: string;
+    name: TranslatedString;
+    icon?: string;
+    type: string;
+    queryId?: string;
+    persistentObjectId?: string;
+    order: number;
+    alias?: string;
+}
+interface ProgramUnitGroup {
+    id: string;
+    name: TranslatedString;
+    icon?: string;
+    order: number;
+    programUnits: ProgramUnit[];
+}
+interface ProgramUnitsConfiguration {
+    programUnitGroups: ProgramUnitGroup[];
+}
+
+declare enum ELookupDisplayType {
+    Dropdown = 0,
+    Modal = 1
+}
+interface LookupReferenceListItem {
+    name: string;
+    isTransient: boolean;
+    valueCount: number;
+    displayType: ELookupDisplayType;
+}
+interface LookupReference {
+    name: string;
+    isTransient: boolean;
+    displayType: ELookupDisplayType;
+    values: LookupReferenceValue[];
+}
+interface LookupReferenceValue {
+    key: string;
+    values: TranslatedString;
+    isActive: boolean;
+    extra?: Record<string, unknown>;
+}
+
+interface RetryActionPayload {
+    type: 'retry-action';
+    step: number;
+    title: string;
+    message?: string;
+    options: string[];
+    defaultOption?: string;
+    persistentObject?: PersistentObject;
+}
+interface RetryActionResult {
+    step: number;
+    option: string;
+    persistentObject?: PersistentObject;
+}
+
+interface EntityPermissions {
+    canRead: boolean;
+    canCreate: boolean;
+    canEdit: boolean;
+    canDelete: boolean;
+}
+
+interface CustomActionDefinition {
+    name: string;
+    displayName: TranslatedString;
+    icon?: string;
+    description?: string;
+    showedOn: string;
+    selectionRule?: string;
+    refreshOnCompleted: boolean;
+    confirmationMessageKey?: string;
+    offset: number;
+}
+
+interface StreamingSnapshotMessage {
+    type: 'snapshot';
+    data: PersistentObject[];
+}
+interface StreamingPatchItem {
+    id: string;
+    attributes: Record<string, any>;
+}
+interface StreamingPatchMessage {
+    type: 'patch';
+    updated: StreamingPatchItem[];
+}
+interface StreamingErrorMessage {
+    type: 'error';
+    message: string;
+}
+type StreamingMessage = StreamingSnapshotMessage | StreamingPatchMessage | StreamingErrorMessage;
+
+export { ELookupDisplayType, ShowedOn, currentLanguage, hasShowedOnFlag, resolveTranslation };
+export type { AttributeGroup, AttributeTab, CustomActionDefinition, EntityAttributeDefinition, EntityPermissions, EntityType, LookupReference, LookupReferenceListItem, LookupReferenceValue, PersistentObject, PersistentObjectAttribute, ProgramUnit, ProgramUnitGroup, ProgramUnitsConfiguration, QueryResult, RetryActionPayload, RetryActionResult, SparkQuery, SparkQueryRenderMode, SparkQuerySortColumn, StreamingErrorMessage, StreamingMessage, StreamingPatchItem, StreamingPatchMessage, StreamingSnapshotMessage, TranslatedString, ValidationError, ValidationErrorResponse, ValidationRule };

package/types/mintplayer-ng-spark-pipes.d.ts

@@ -0,0 +1,143 @@
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { TranslatedString, PersistentObject, EntityType, LookupReference, EntityAttributeDefinition, ProgramUnit, EntityPermissions, ELookupDisplayType, LookupReferenceValue, ValidationError } from '@mintplayer/ng-spark/models';
+
+declare class TranslateKeyPipe implements PipeTransform {
+    private readonly lang;
+    transform(key: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslateKeyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TranslateKeyPipe, "t", true>;
+}
+
+declare class ResolveTranslationPipe implements PipeTransform {
+    transform(value: TranslatedString | undefined, fallback?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveTranslationPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ResolveTranslationPipe, "resolveTranslation", true>;
+}
+
+declare class InputTypePipe implements PipeTransform {
+    transform(dataType: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InputTypePipe, "inputType", true>;
+}
+
+declare class AttributeValuePipe implements PipeTransform {
+    transform(attrName: string, item: PersistentObject | null, entityType: EntityType | null, lookupRefOptions: Record<string, LookupReference>, allEntityTypes: EntityType[]): any;
+    private formatAsDetailValue;
+    private resolveDisplayFormat;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttributeValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AttributeValuePipe, "attributeValue", true>;
+}
+
+declare class RawAttributeValuePipe implements PipeTransform {
+    transform(attrName: string, item: PersistentObject | null): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RawAttributeValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RawAttributeValuePipe, "rawAttributeValue", true>;
+}
+
+declare class ReferenceDisplayValuePipe implements PipeTransform {
+    private readonly lang;
+    transform(attr: EntityAttributeDefinition, formData: Record<string, any>, referenceOptions: Record<string, PersistentObject[]>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReferenceDisplayValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReferenceDisplayValuePipe, "referenceDisplayValue", true>;
+}
+
+declare class ReferenceAttrValuePipe implements PipeTransform {
+    transform(item: PersistentObject, attrName: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReferenceAttrValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReferenceAttrValuePipe, "referenceAttrValue", true>;
+}
+
+declare class ReferenceLinkRoutePipe implements PipeTransform {
+    transform(referenceClrType: string, referenceId: any, allEntityTypes: EntityType[]): string[] | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReferenceLinkRoutePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReferenceLinkRoutePipe, "referenceLinkRoute", true>;
+}
+
+declare class RouterLinkPipe implements PipeTransform {
+    transform(unit: ProgramUnit): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RouterLinkPipe, "routerLink", true>;
+}
+
+declare class AsDetailTypePipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, asDetailTypes: Record<string, EntityType>): EntityType | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsDetailTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsDetailTypePipe, "asDetailType", true>;
+}
+
+declare class AsDetailColumnsPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, asDetailTypes: Record<string, EntityType>): EntityAttributeDefinition[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsDetailColumnsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsDetailColumnsPipe, "asDetailColumns", true>;
+}
+
+declare class AsDetailCellValuePipe implements PipeTransform {
+    transform(row: Record<string, any>, parentAttr: EntityAttributeDefinition, col: EntityAttributeDefinition, asDetailRefOptions: Record<string, Record<string, PersistentObject[]>>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsDetailCellValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsDetailCellValuePipe, "asDetailCellValue", true>;
+}
+
+declare class AsDetailDisplayValuePipe implements PipeTransform {
+    private readonly lang;
+    transform(attr: EntityAttributeDefinition, formData: Record<string, any>, asDetailTypes: Record<string, EntityType>): string;
+    private resolveDisplayFormat;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsDetailDisplayValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsDetailDisplayValuePipe, "asDetailDisplayValue", true>;
+}
+
+declare class CanCreateDetailRowPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, permissions: Record<string, EntityPermissions>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanCreateDetailRowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CanCreateDetailRowPipe, "canCreateDetailRow", true>;
+}
+
+declare class CanDeleteDetailRowPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, permissions: Record<string, EntityPermissions>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanDeleteDetailRowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CanDeleteDetailRowPipe, "canDeleteDetailRow", true>;
+}
+
+declare class LookupDisplayTypePipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, lookupRefOptions: Record<string, LookupReference>): ELookupDisplayType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LookupDisplayTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LookupDisplayTypePipe, "lookupDisplayType", true>;
+}
+
+declare class LookupDisplayValuePipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, formData: Record<string, any>, lookupRefOptions: Record<string, LookupReference>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LookupDisplayValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LookupDisplayValuePipe, "lookupDisplayValue", true>;
+}
+
+declare class LookupOptionsPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, lookupRefOptions: Record<string, LookupReference>): LookupReferenceValue[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<LookupOptionsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LookupOptionsPipe, "lookupOptions", true>;
+}
+
+declare class InlineRefOptionsPipe implements PipeTransform {
+    transform(parentAttr: EntityAttributeDefinition, col: EntityAttributeDefinition, asDetailRefOptions: Record<string, Record<string, PersistentObject[]>>): PersistentObject[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineRefOptionsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InlineRefOptionsPipe, "inlineRefOptions", true>;
+}
+
+declare class ErrorForAttributePipe implements PipeTransform {
+    transform(attrName: string, validationErrors: ValidationError[]): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorForAttributePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ErrorForAttributePipe, "errorForAttribute", true>;
+}
+
+declare class IconNamePipe implements PipeTransform {
+    transform(value: string | undefined, fallback: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconNamePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IconNamePipe, "iconName", true>;
+}
+
+declare class ArrayValuePipe implements PipeTransform {
+    transform(attrName: string, item: PersistentObject | null): Record<string, any>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayValuePipe, "arrayValue", true>;
+}
+
+export { ArrayValuePipe, AsDetailCellValuePipe, AsDetailColumnsPipe, AsDetailDisplayValuePipe, AsDetailTypePipe, AttributeValuePipe, CanCreateDetailRowPipe, CanDeleteDetailRowPipe, ErrorForAttributePipe, IconNamePipe, InlineRefOptionsPipe, InputTypePipe, LookupDisplayTypePipe, LookupDisplayValuePipe, LookupOptionsPipe, RawAttributeValuePipe, ReferenceAttrValuePipe, ReferenceDisplayValuePipe, ReferenceLinkRoutePipe, ResolveTranslationPipe, RouterLinkPipe, TranslateKeyPipe };

package/types/mintplayer-ng-spark-po-create.d.ts

@@ -0,0 +1,29 @@
+import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
+import { PersistentObject, EntityType, ValidationError } from '@mintplayer/ng-spark/models';
+import * as _angular_core from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+
+declare class SparkPoCreateComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    saved: _angular_core.OutputEmitterRef<PersistentObject>;
+    cancelled: _angular_core.OutputEmitterRef<void>;
+    colors: typeof Color;
+    entityType: _angular_core.WritableSignal<EntityType>;
+    type: _angular_core.WritableSignal<string>;
+    formData: _angular_core.WritableSignal<Record<string, any>>;
+    validationErrors: _angular_core.WritableSignal<ValidationError[]>;
+    isSaving: _angular_core.WritableSignal<boolean>;
+    generalErrors: _angular_core.Signal<ValidationError[]>;
+    constructor();
+    private onParamsChange;
+    initFormData(): void;
+    getEditableAttributes(): _mintplayer_ng_spark_models.EntityAttributeDefinition[];
+    onSave(): Promise<void>;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoCreateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoCreateComponent, "spark-po-create", never, {}, { "saved": "saved"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+export { SparkPoCreateComponent };

package/types/mintplayer-ng-spark-po-detail.d.ts

@@ -0,0 +1,88 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { PersistentObject, EntityType, CustomActionDefinition, LookupReference, EntityAttributeDefinition, AttributeTab, AttributeGroup, SparkQuery } from '@mintplayer/ng-spark/models';
+import { DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
+import { VirtualDatatableDataSource } from '@mintplayer/ng-bootstrap/virtual-datatable';
+import { PaginationResponse } from '@mintplayer/pagination';
+
+declare class SparkPoDetailComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    private readonly lang;
+    private readonly rendererRegistry;
+    showCustomActions: _angular_core.InputSignal<boolean>;
+    extraActionsTemplate: _angular_core.InputSignal<TemplateRef<void>>;
+    extraContentTemplate: _angular_core.InputSignal<TemplateRef<{
+        $implicit: PersistentObject;
+        entityType: EntityType;
+    }>>;
+    edited: _angular_core.OutputEmitterRef<void>;
+    deleted: _angular_core.OutputEmitterRef<void>;
+    customActionExecuted: _angular_core.OutputEmitterRef<{
+        action: CustomActionDefinition;
+        item: PersistentObject;
+    }>;
+    colors: typeof Color;
+    errorMessage: _angular_core.WritableSignal<string>;
+    entityType: _angular_core.WritableSignal<EntityType>;
+    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
+    item: _angular_core.WritableSignal<PersistentObject>;
+    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
+    asDetailTypes: _angular_core.WritableSignal<Record<string, EntityType>>;
+    asDetailReferenceOptions: _angular_core.WritableSignal<Record<string, Record<string, PersistentObject[]>>>;
+    type: string;
+    id: string;
+    canEdit: _angular_core.WritableSignal<boolean>;
+    canDelete: _angular_core.WritableSignal<boolean>;
+    customActions: _angular_core.WritableSignal<CustomActionDefinition[]>;
+    constructor();
+    private onParamsChange;
+    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    private static readonly DEFAULT_TAB;
+    ungroupedAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    resolvedTabs: _angular_core.Signal<AttributeTab[]>;
+    groupsForTab(tab: AttributeTab): AttributeGroup[];
+    attrsForGroup(group: AttributeGroup): EntityAttributeDefinition[];
+    getDetailRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
+    getDetailRendererInputs(attr: EntityAttributeDefinition, item: PersistentObject): Record<string, any>;
+    private loadLookupReferenceOptions;
+    private loadAsDetailTypes;
+    onCustomAction(action: CustomActionDefinition): Promise<void>;
+    onEdit(): void;
+    onDelete(): Promise<void>;
+    onBack(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoDetailComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoDetailComponent, "spark-po-detail", never, { "showCustomActions": { "alias": "showCustomActions"; "required": false; "isSignal": true; }; "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; "extraContentTemplate": { "alias": "extraContentTemplate"; "required": false; "isSignal": true; }; }, { "edited": "edited"; "deleted": "deleted"; "customActionExecuted": "customActionExecuted"; }, never, never, true, never>;
+}
+
+declare class SparkSubQueryComponent {
+    private readonly sparkService;
+    private readonly rendererRegistry;
+    queryId: _angular_core.InputSignal<string>;
+    parentId: _angular_core.InputSignal<string>;
+    parentType: _angular_core.InputSignal<string>;
+    query: _angular_core.WritableSignal<SparkQuery>;
+    entityType: _angular_core.WritableSignal<EntityType>;
+    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
+    paginationData: _angular_core.WritableSignal<PaginationResponse<PersistentObject>>;
+    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
+    loading: _angular_core.WritableSignal<boolean>;
+    canRead: _angular_core.WritableSignal<boolean>;
+    settings: _angular_core.WritableSignal<DatatableSettings>;
+    virtualDataSource: _angular_core.WritableSignal<VirtualDatatableDataSource<PersistentObject>>;
+    virtualSettings: _angular_core.WritableSignal<DatatableSettings>;
+    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    constructor();
+    private loadData;
+    private loadPage;
+    onSettingsChange(): void;
+    private loadLookupReferenceOptions;
+    getColumnRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
+    getColumnRendererInputs(item: PersistentObject, attr: EntityAttributeDefinition): Record<string, any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkSubQueryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkSubQueryComponent, "spark-sub-query", never, { "queryId": { "alias": "queryId"; "required": true; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": true; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SparkPoDetailComponent, SparkSubQueryComponent };

package/types/mintplayer-ng-spark-po-edit.d.ts

@@ -0,0 +1,31 @@
+import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
+import { PersistentObject, EntityType, ValidationError } from '@mintplayer/ng-spark/models';
+import * as _angular_core from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+
+declare class SparkPoEditComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    saved: _angular_core.OutputEmitterRef<PersistentObject>;
+    cancelled: _angular_core.OutputEmitterRef<void>;
+    colors: typeof Color;
+    entityType: _angular_core.WritableSignal<EntityType>;
+    item: _angular_core.WritableSignal<PersistentObject>;
+    type: string;
+    id: string;
+    formData: _angular_core.WritableSignal<Record<string, any>>;
+    validationErrors: _angular_core.WritableSignal<ValidationError[]>;
+    isSaving: _angular_core.WritableSignal<boolean>;
+    generalErrors: _angular_core.Signal<ValidationError[]>;
+    constructor();
+    private onParamsChange;
+    initFormData(): void;
+    getEditableAttributes(): _mintplayer_ng_spark_models.EntityAttributeDefinition[];
+    onSave(): Promise<void>;
+    onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoEditComponent, "spark-po-edit", never, {}, { "saved": "saved"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+export { SparkPoEditComponent };