@mintplayer/ng-spark 0.0.1

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

@@ -0,0 +1,702 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef, QueryList, PipeTransform, Provider } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
+import { PaginationResponse } from '@mintplayer/pagination';
+import * as _mintplayer_ng_spark from '@mintplayer/ng-spark';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { SafeHtml } from '@angular/platform-browser';
+import { Route, Routes } from '@angular/router';
+
+/**
+ * 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;
+
+type TranslatedString = Record<string, string>;
+declare function resolveTranslation(ts: TranslatedString | undefined, lang?: string): string;
+
+interface ValidationRule {
+    type: string;
+    value?: any;
+    min?: number;
+    max?: number;
+    message?: TranslatedString;
+}
+
+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[];
+}
+
+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[];
+}
+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;
+    attributes: EntityAttributeDefinition[];
+}
+
+interface ValidationError {
+    attributeName: string;
+    errorMessage: TranslatedString;
+    ruleType: string;
+}
+
+interface SparkQuery {
+    id: string;
+    name: string;
+    description?: TranslatedString;
+    contextProperty: string;
+    alias?: string;
+    sortBy?: string;
+    sortDirection: string;
+    /** Optional RavenDB index name for queries using indexes */
+    indexName?: string;
+    /** When true, uses the projection type from [QueryType] attribute */
+    useProjection?: boolean;
+}
+
+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 {
+    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 SparkConfig {
+    baseUrl: string;
+}
+declare const SPARK_CONFIG: InjectionToken<SparkConfig>;
+declare const defaultSparkConfig: SparkConfig;
+
+declare class SparkService {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly http;
+    private readonly retryActionService;
+    getEntityTypes(): Promise<EntityType[]>;
+    getEntityType(id: string): Promise<EntityType>;
+    getEntityTypeByClrType(clrType: string): Promise<EntityType | undefined>;
+    getPermissions(entityTypeId: string): Promise<EntityPermissions>;
+    getQueries(): Promise<SparkQuery[]>;
+    getQuery(id: string): Promise<SparkQuery>;
+    getQueryByName(name: string): Promise<SparkQuery | undefined>;
+    executeQuery(queryId: string, sortBy?: string, sortDirection?: string): Promise<PersistentObject[]>;
+    executeQueryByName(queryName: string): Promise<PersistentObject[]>;
+    getProgramUnits(): Promise<ProgramUnitsConfiguration>;
+    list(type: string): Promise<PersistentObject[]>;
+    get(type: string, id: string): Promise<PersistentObject>;
+    create(type: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
+    update(type: string, id: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
+    delete(type: string, id: string): Promise<void>;
+    getCustomActions(objectTypeId: string): Promise<CustomActionDefinition[]>;
+    executeCustomAction(objectTypeId: string, actionName: string, parent?: PersistentObject, selectedItems?: PersistentObject[]): Promise<void>;
+    getLookupReferences(): Promise<LookupReferenceListItem[]>;
+    getLookupReference(name: string): Promise<LookupReference>;
+    addLookupReferenceValue(name: string, value: LookupReferenceValue): Promise<LookupReferenceValue>;
+    updateLookupReferenceValue(name: string, key: string, value: LookupReferenceValue): Promise<LookupReferenceValue>;
+    deleteLookupReferenceValue(name: string, key: string): Promise<void>;
+    private postWithRetry;
+    private putWithRetry;
+    private deleteWithRetry;
+    private handleRetryError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SparkService>;
+}
+
+declare class SparkLanguageService {
+    private readonly http;
+    private readonly config;
+    private readonly baseUrl;
+    private readonly currentLang;
+    private readonly translationsMap;
+    readonly language: _angular_core.Signal<string>;
+    readonly languages: _angular_core.WritableSignal<Record<string, TranslatedString>>;
+    constructor();
+    private loadCulture;
+    private loadTranslations;
+    setLanguage(lang: string): void;
+    resolve(ts: TranslatedString | undefined): string;
+    t(key: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkLanguageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SparkLanguageService>;
+}
+
+declare class RetryActionService {
+    private resolveRetry;
+    payload: _angular_core.WritableSignal<RetryActionPayload>;
+    show(payload: RetryActionPayload): Promise<RetryActionResult>;
+    respond(result: RetryActionResult): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RetryActionService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RetryActionService>;
+}
+
+interface SparkFieldTemplateContext {
+    $implicit: EntityAttributeDefinition;
+    formData: Record<string, any>;
+    value: any;
+    hasError: boolean;
+    errorMessage: TranslatedString | null;
+}
+declare class SparkFieldTemplateDirective {
+    template: TemplateRef<SparkFieldTemplateContext>;
+    name: _angular_core.InputSignal<string>;
+    constructor(template: TemplateRef<SparkFieldTemplateContext>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkFieldTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SparkFieldTemplateDirective, "[sparkFieldTemplate]", never, { "name": { "alias": "sparkFieldTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SparkPoFormComponent {
+    private readonly sparkService;
+    private readonly translations;
+    fieldTemplates: QueryList<SparkFieldTemplateDirective>;
+    entityType: _angular_core.InputSignal<EntityType>;
+    formData: _angular_core.ModelSignal<Record<string, any>>;
+    validationErrors: _angular_core.InputSignal<ValidationError[]>;
+    showButtons: _angular_core.InputSignal<boolean>;
+    isSaving: _angular_core.InputSignal<boolean>;
+    externalFieldTemplates: _angular_core.InputSignal<SparkFieldTemplateDirective[]>;
+    save: _angular_core.OutputEmitterRef<void>;
+    cancel: _angular_core.OutputEmitterRef<void>;
+    colors: typeof Color;
+    referenceOptions: _angular_core.WritableSignal<Record<string, PersistentObject[]>>;
+    asDetailTypes: _angular_core.WritableSignal<Record<string, EntityType>>;
+    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
+    editingAsDetailAttr: _angular_core.WritableSignal<EntityAttributeDefinition>;
+    asDetailFormData: _angular_core.WritableSignal<Record<string, any>>;
+    showAsDetailModal: _angular_core.WritableSignal<boolean>;
+    editingArrayIndex: _angular_core.WritableSignal<number>;
+    asDetailPermissions: _angular_core.WritableSignal<Record<string, EntityPermissions>>;
+    asDetailReferenceOptions: _angular_core.WritableSignal<Record<string, Record<string, PersistentObject[]>>>;
+    editingReferenceAttr: _angular_core.WritableSignal<EntityAttributeDefinition>;
+    showReferenceModal: _angular_core.WritableSignal<boolean>;
+    referenceModalItems: _angular_core.WritableSignal<PersistentObject[]>;
+    referenceModalEntityType: _angular_core.WritableSignal<EntityType>;
+    referenceModalPagination: _angular_core.WritableSignal<PaginationResponse<PersistentObject>>;
+    referenceModalSettings: DatatableSettings;
+    referenceSearchTerm: string;
+    editingLookupAttr: _angular_core.WritableSignal<EntityAttributeDefinition>;
+    showLookupModal: _angular_core.WritableSignal<boolean>;
+    lookupModalItems: _angular_core.WritableSignal<LookupReferenceValue[]>;
+    lookupSearchTerm: _angular_core.WritableSignal<string>;
+    ELookupDisplayType: typeof ELookupDisplayType;
+    editableAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    referenceVisibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    filteredLookupItems: _angular_core.Signal<LookupReferenceValue[]>;
+    getFieldTemplate(attr: EntityAttributeDefinition): TemplateRef<SparkFieldTemplateContext> | null;
+    getFieldTemplateContext(attr: EntityAttributeDefinition): SparkFieldTemplateContext;
+    constructor();
+    private toRecord;
+    loadReferenceOptions(): Promise<void>;
+    loadAsDetailTypes(): Promise<void>;
+    loadLookupReferenceOptions(): Promise<void>;
+    getReferenceOptions(attr: EntityAttributeDefinition): PersistentObject[];
+    getLookupOptions(attr: EntityAttributeDefinition): LookupReferenceValue[];
+    openLookupSelector(attr: EntityAttributeDefinition): void;
+    selectLookupItem(item: LookupReferenceValue): void;
+    closeLookupModal(): void;
+    hasError(attrName: string): boolean;
+    onFieldChange(): void;
+    onSave(): void;
+    onCancel(): void;
+    openAsDetailEditor(attr: EntityAttributeDefinition): void;
+    saveAsDetailObject(): void;
+    closeAsDetailModal(): void;
+    addInlineRow(attr: EntityAttributeDefinition): void;
+    addArrayItem(attr: EntityAttributeDefinition): void;
+    editArrayItem(attr: EntityAttributeDefinition, index: number): void;
+    removeArrayItem(attr: EntityAttributeDefinition, index: number): void;
+    openReferenceSelector(attr: EntityAttributeDefinition): Promise<void>;
+    onReferenceSearchChange(): void;
+    applyReferenceFilter(): void;
+    clearReferenceSearch(): void;
+    selectReferenceItem(item: PersistentObject): void;
+    closeReferenceModal(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, { "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "isSaving": { "alias": "isSaving"; "required": false; "isSignal": true; }; "externalFieldTemplates": { "alias": "externalFieldTemplates"; "required": false; "isSignal": true; }; }, { "formData": "formDataChange"; "save": "save"; "cancel": "cancel"; }, ["fieldTemplates"], never, true, never>;
+}
+
+declare class SparkPoCreateComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    fieldTemplates: QueryList<SparkFieldTemplateDirective>;
+    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.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"; }, ["fieldTemplates"], never, true, never>;
+}
+
+declare class SparkPoEditComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    fieldTemplates: QueryList<SparkFieldTemplateDirective>;
+    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.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"; }, ["fieldTemplates"], never, true, never>;
+}
+
+interface SparkDetailFieldTemplateContext {
+    $implicit: EntityAttributeDefinition;
+    item: PersistentObject;
+    value: any;
+}
+declare class SparkDetailFieldTemplateDirective {
+    template: TemplateRef<SparkDetailFieldTemplateContext>;
+    name: _angular_core.InputSignal<string>;
+    constructor(template: TemplateRef<SparkDetailFieldTemplateContext>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkDetailFieldTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SparkDetailFieldTemplateDirective, "[sparkDetailFieldTemplate]", never, { "name": { "alias": "sparkDetailFieldTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SparkPoDetailComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    private readonly lang;
+    detailFieldTemplates: QueryList<SparkDetailFieldTemplateDirective>;
+    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[]>;
+    getDetailFieldTemplate(attr: EntityAttributeDefinition): TemplateRef<SparkDetailFieldTemplateContext> | null;
+    getDetailFieldContext(attr: EntityAttributeDefinition, item: PersistentObject): SparkDetailFieldTemplateContext;
+    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"; }, ["detailFieldTemplates"], never, true, never>;
+}
+
+interface SparkColumnTemplateContext {
+    $implicit: PersistentObject;
+    attr: EntityAttributeDefinition;
+    value: any;
+}
+declare class SparkColumnTemplateDirective {
+    template: TemplateRef<SparkColumnTemplateContext>;
+    name: _angular_core.InputSignal<string>;
+    constructor(template: TemplateRef<SparkColumnTemplateContext>);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkColumnTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SparkColumnTemplateDirective, "[sparkColumnTemplate]", never, { "name": { "alias": "sparkColumnTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SparkQueryListComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    columnTemplates: QueryList<SparkColumnTemplateDirective>;
+    extraActionsTemplate: _angular_core.InputSignal<TemplateRef<void>>;
+    rowClicked: _angular_core.OutputEmitterRef<PersistentObject>;
+    createClicked: _angular_core.OutputEmitterRef<void>;
+    colors: typeof Color;
+    errorMessage: _angular_core.WritableSignal<string>;
+    query: _angular_core.WritableSignal<SparkQuery>;
+    entityType: _angular_core.WritableSignal<EntityType>;
+    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
+    allItems: _angular_core.WritableSignal<PersistentObject[]>;
+    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
+    paginationData: _angular_core.WritableSignal<PaginationResponse<PersistentObject>>;
+    searchTerm: string;
+    canCreate: _angular_core.WritableSignal<boolean>;
+    settings: DatatableSettings;
+    private currentSortProperty;
+    private currentSortDirection;
+    constructor();
+    private onParamsChange;
+    private resolveEntityTypeForQuery;
+    private singularize;
+    loadItems(): Promise<void>;
+    onSettingsChange(): void;
+    onSearchChange(): void;
+    applyFilter(): void;
+    clearSearch(): void;
+    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    getColumnTemplate(attr: EntityAttributeDefinition): TemplateRef<SparkColumnTemplateContext> | null;
+    getColumnTemplateContext(item: PersistentObject, attr: EntityAttributeDefinition): SparkColumnTemplateContext;
+    private loadLookupReferenceOptions;
+    onRowClick(item: PersistentObject): void;
+    onCreate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkQueryListComponent, "spark-query-list", never, { "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; }, { "rowClicked": "rowClicked"; "createClicked": "createClicked"; }, ["columnTemplates"], never, true, never>;
+}
+
+declare class SparkRetryActionModalComponent {
+    protected readonly retryActionService: RetryActionService;
+    colors: typeof Color;
+    isOpen: _angular_core.Signal<boolean>;
+    onOption(option: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkRetryActionModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkRetryActionModalComponent, "spark-retry-action-modal", never, {}, {}, never, never, true, never>;
+}
+
+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>;
+}
+
+declare class SparkIconRegistry {
+    private sanitizer;
+    private icons;
+    constructor();
+    register(name: string, svg: string): void;
+    get(name: string): SafeHtml | undefined;
+    has(name: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkIconRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SparkIconRegistry>;
+}
+
+declare class TranslateKeyPipe implements PipeTransform {
+    private readonly lang;
+    transform(key: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslateKeyPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TranslateKeyPipe, "t", true>;
+}
+
+declare class ResolveTranslationPipe implements PipeTransform {
+    transform(value: TranslatedString | undefined, fallback?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResolveTranslationPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ResolveTranslationPipe, "resolveTranslation", true>;
+}
+
+declare class InputTypePipe implements PipeTransform {
+    transform(dataType: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<AttributeValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<AttributeValuePipe, "attributeValue", true>;
+}
+
+declare class RawAttributeValuePipe implements PipeTransform {
+    transform(attrName: string, item: PersistentObject | null): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RawAttributeValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<ReferenceDisplayValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ReferenceDisplayValuePipe, "referenceDisplayValue", true>;
+}
+
+declare class ReferenceAttrValuePipe implements PipeTransform {
+    transform(item: PersistentObject, attrName: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReferenceAttrValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ReferenceAttrValuePipe, "referenceAttrValue", true>;
+}
+
+declare class ReferenceLinkRoutePipe implements PipeTransform {
+    transform(referenceClrType: string, referenceId: any, allEntityTypes: EntityType[]): string[] | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReferenceLinkRoutePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ReferenceLinkRoutePipe, "referenceLinkRoute", true>;
+}
+
+declare class RouterLinkPipe implements PipeTransform {
+    transform(unit: ProgramUnit): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RouterLinkPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<RouterLinkPipe, "routerLink", true>;
+}
+
+declare class AsDetailTypePipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, asDetailTypes: Record<string, EntityType>): EntityType | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AsDetailTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<AsDetailTypePipe, "asDetailType", true>;
+}
+
+declare class AsDetailColumnsPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, asDetailTypes: Record<string, EntityType>): EntityAttributeDefinition[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AsDetailColumnsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<AsDetailCellValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵ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: _angular_core.ɵɵFactoryDeclaration<AsDetailDisplayValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<AsDetailDisplayValuePipe, "asDetailDisplayValue", true>;
+}
+
+declare class CanCreateDetailRowPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, permissions: Record<string, EntityPermissions>): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CanCreateDetailRowPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CanCreateDetailRowPipe, "canCreateDetailRow", true>;
+}
+
+declare class CanDeleteDetailRowPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, permissions: Record<string, EntityPermissions>): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CanDeleteDetailRowPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CanDeleteDetailRowPipe, "canDeleteDetailRow", true>;
+}
+
+declare class LookupDisplayTypePipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, lookupRefOptions: Record<string, LookupReference>): ELookupDisplayType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LookupDisplayTypePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LookupDisplayTypePipe, "lookupDisplayType", true>;
+}
+
+declare class LookupDisplayValuePipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, formData: Record<string, any>, lookupRefOptions: Record<string, LookupReference>): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LookupDisplayValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LookupDisplayValuePipe, "lookupDisplayValue", true>;
+}
+
+declare class LookupOptionsPipe implements PipeTransform {
+    transform(attr: EntityAttributeDefinition, lookupRefOptions: Record<string, LookupReference>): LookupReferenceValue[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LookupOptionsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LookupOptionsPipe, "lookupOptions", true>;
+}
+
+declare class InlineRefOptionsPipe implements PipeTransform {
+    transform(parentAttr: EntityAttributeDefinition, col: EntityAttributeDefinition, asDetailRefOptions: Record<string, Record<string, PersistentObject[]>>): PersistentObject[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InlineRefOptionsPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<InlineRefOptionsPipe, "inlineRefOptions", true>;
+}
+
+declare class ErrorForAttributePipe implements PipeTransform {
+    transform(attrName: string, validationErrors: ValidationError[]): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorForAttributePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ErrorForAttributePipe, "errorForAttribute", true>;
+}
+
+declare class IconNamePipe implements PipeTransform {
+    transform(value: string | undefined, fallback: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconNamePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<IconNamePipe, "iconName", true>;
+}
+
+declare class ArrayValuePipe implements PipeTransform {
+    transform(attrName: string, item: PersistentObject | null): Record<string, any>[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrayValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ArrayValuePipe, "arrayValue", true>;
+}
+
+interface SparkRouteConfig {
+    queryList?: Route['loadComponent'];
+    poCreate?: Route['loadComponent'];
+    poEdit?: Route['loadComponent'];
+    poDetail?: Route['loadComponent'];
+}
+declare function sparkRoutes(config?: SparkRouteConfig): Routes;
+
+declare function provideSpark(config?: Partial<SparkConfig>): Provider[];
+
+export { ArrayValuePipe, AsDetailCellValuePipe, AsDetailColumnsPipe, AsDetailDisplayValuePipe, AsDetailTypePipe, AttributeValuePipe, CanCreateDetailRowPipe, CanDeleteDetailRowPipe, ELookupDisplayType, ErrorForAttributePipe, IconNamePipe, InlineRefOptionsPipe, InputTypePipe, LookupDisplayTypePipe, LookupDisplayValuePipe, LookupOptionsPipe, RawAttributeValuePipe, ReferenceAttrValuePipe, ReferenceDisplayValuePipe, ReferenceLinkRoutePipe, ResolveTranslationPipe, RetryActionService, RouterLinkPipe, SPARK_CONFIG, ShowedOn, SparkColumnTemplateDirective, SparkDetailFieldTemplateDirective, SparkFieldTemplateDirective, SparkIconComponent, SparkIconRegistry, SparkLanguageService, SparkPoCreateComponent, SparkPoDetailComponent, SparkPoEditComponent, SparkPoFormComponent, SparkQueryListComponent, SparkRetryActionModalComponent, SparkService, TranslateKeyPipe, defaultSparkConfig, hasShowedOnFlag, provideSpark, resolveTranslation, sparkRoutes };
+export type { CustomActionDefinition, EntityAttributeDefinition, EntityPermissions, EntityType, LookupReference, LookupReferenceListItem, LookupReferenceValue, PersistentObject, PersistentObjectAttribute, ProgramUnit, ProgramUnitGroup, ProgramUnitsConfiguration, RetryActionPayload, RetryActionResult, SparkColumnTemplateContext, SparkConfig, SparkDetailFieldTemplateContext, SparkFieldTemplateContext, SparkQuery, SparkRouteConfig, TranslatedString, ValidationError, ValidationRule };