nuxeo-development-framework 0.0.2 → 0.0.3-bos

package/lib/components/user/user/user.component.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import { AppConfigService } from '../../../configuration/app-config.service';
+import * as i0 from "@angular/core";
+export declare class UserComponent implements OnInit {
+    appconfService: AppConfigService;
+    user: any;
+    type: string;
+    textColor: any;
+    constructor(appconfService: AppConfigService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserComponent, "app-user", never, { "user": { "alias": "user"; "required": false; }; "type": { "alias": "type"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/user/user.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./user/user.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../avatar/avatar.module";
+import * as i4 from "@ngx-translate/core";
+export declare class UserModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UserModule, [typeof i1.UserComponent], [typeof i2.CommonModule, typeof i3.AvatarModule, typeof i4.TranslateModule], [typeof i1.UserComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UserModule>;
+}

package/lib/components/users-card/users-card.component.d.ts

@@ -0,0 +1,22 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A UI component to view an array of users
+ *
+ * ![Screenshot-1](../screenshots/usersCard.png)
+ * @title
+ * Users Card
+ *
+ * @example
+ *  <app-users-card [title]="'List of users'" [members]="users"></app-users-card>
+ */
+export declare class UsersCardComponent implements OnInit {
+    /** Array of Nuxeo user objects */
+    members: any[];
+    /** Card title */
+    title: string;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsersCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UsersCardComponent, "app-users-card", never, { "members": { "alias": "members"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/users-card/users-card.module.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./users-card.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@angular/material/tooltip";
+import * as i5 from "../card/card.module";
+import * as i6 from "../avatar/avatar.module";
+import * as i7 from "@angular/router";
+/**
+ * @title
+ * Users card module
+ */
+export declare class UsersCardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UsersCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UsersCardModule, [typeof i1.UsersCardComponent], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4.MatTooltipModule, typeof i5.CardModule, typeof i6.AvatarModule, typeof i7.RouterModule], [typeof i1.UsersCardComponent, typeof i7.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UsersCardModule>;
+}

package/lib/components/viewer-log/components/viewer-log/viewer-log.component.d.ts

@@ -0,0 +1,14 @@
+import { OnInit, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ViewerLogComponent implements OnInit {
+    loading: boolean;
+    correspondence: any;
+    newLogActor: boolean;
+    isArabic: any;
+    constructor();
+    logSuccess(e: any): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerLogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewerLogComponent, "cts-viewer-log", never, { "correspondence": { "alias": "correspondence"; "required": false; }; "newLogActor": { "alias": "newLogActor"; "required": false; }; "isArabic": { "alias": "isArabic"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/viewer-log/viewer-log.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/viewer-log/viewer-log.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../latest-activity/latest-activity.module";
+import * as i4 from "@angular/material/progress-bar";
+export declare class ViewerLogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewerLogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ViewerLogModule, [typeof i1.ViewerLogComponent], [typeof i2.CommonModule, typeof i3.LatestActivityModule, typeof i4.MatProgressBarModule], [typeof i1.ViewerLogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ViewerLogModule>;
+}

package/lib/components/vocabulary/interfaces/op-type.interface.d.ts

@@ -0,0 +1 @@
+export type opType = 'AC_UA_Vocabulary_AddEntry' | 'AC_UA_Vocabulary_UpdateEntry' | 'AC_UA_Vocabulary_RemoveEntry';

package/lib/components/vocabulary/services/vocabulary-api.service.d.ts

@@ -0,0 +1,19 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';
+import { BaseService } from '../../../shared/services/base/base.service';
+import { opType } from '../interfaces/op-type.interface';
+import * as i0 from "@angular/core";
+export declare class VocabularyApiService extends BaseService {
+    private nuxeoService;
+    private injector;
+    vocabular: {};
+    constructor(nuxeoService: NuxeoService, injector: Injector);
+    getVocabularyList(listName: any): Observable<any>;
+    getVocabularyListByFilters(listName: any, params?: {}, filter?: {}, fullText?: any): Observable<any>;
+    actualGetVocabularyList(params: Record<string, any>): Observable<any>;
+    vocabularyOperations(opName: opType, body: any): Observable<unknown>;
+    getVocListByVocName(vocName: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VocabularyApiService>;
+}

package/lib/components/vocabulary/translated-vocabulary-select/translated-vocabulary-select.component.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter, OnChanges, OnDestroy } from "@angular/core";
+import { ControlValueAccessor, UntypedFormControl, NgControl } from "@angular/forms";
+import { NgSelectComponent } from "@ng-select/ng-select";
+import { TranslateService } from "@ngx-translate/core";
+import { TranslationService } from "../../../core/services/translation/translation.service";
+import { VocabularyApiService } from "../services/vocabulary-api.service";
+import * as i0 from "@angular/core";
+export declare class TranslatedVocabularySelectComponent implements OnChanges, OnDestroy, ControlValueAccessor {
+    translate: TranslateService;
+    private translationService;
+    private vocabularyApiServ;
+    control: NgControl;
+    ngSelectComponent: NgSelectComponent;
+    /** Field Label */
+    label: string;
+    /** Property name to bind value to */
+    bindValue: any;
+    /** Property name to bind label to */
+    arbBindLabel: any;
+    /** Property name to bind label to */
+    engBindLabel: any;
+    /** Items array */
+    /** Placeholder string */
+    placeholder: any;
+    /** can select multiple */
+    multiple: boolean;
+    /** is searchable */
+    searchable: boolean;
+    /** should close on select */
+    closeOnSelect: boolean;
+    /** should hide selected items */
+    hideSelectedItems: boolean;
+    /** is disabled */
+    disabled: boolean;
+    /** should show clear action */
+    clear: boolean;
+    /** filter to be sent from out side to send it in api to filter the vocabulary items */
+    filter: any;
+    /** flage to indicate if call api without filter or wait untile there is filter and then call api*/
+    useFilter: boolean;
+    /** is vocabulary select */
+    /** vocabulary id for translation (for vocabulary select only) */
+    vocbularyId: string;
+    /** Should show loading indicator */
+    loading: boolean;
+    mapingResponse: boolean;
+    params: {};
+    getByDirectorySuggestion: boolean;
+    /** event emitted with selected items */
+    onSelectItems: EventEmitter<any>;
+    bindLabel: any;
+    selection: any[];
+    data: any[];
+    buffer: any[];
+    bufferSize: number;
+    numberOfItemsFromEndBeforeFetchingMore: number;
+    private _unsubscribeAll;
+    isArabic: boolean;
+    propagateChange: any;
+    validateFn: any;
+    onTouched: any;
+    get invalid(): boolean;
+    get showError(): boolean;
+    constructor(translate: TranslateService, translationService: TranslationService, vocabularyApiServ: VocabularyApiService, control: NgControl);
+    ngOnInit(): void;
+    getlistOfVocabulary(): void;
+    ngOnChanges(changes: any): void;
+    emitSelection(event: any): void;
+    onScrollToEnd(): void;
+    private fetchMore;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    validate(c: UntypedFormControl): any;
+    isRequired(): any;
+    hasErrors(): boolean;
+    reset(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslatedVocabularySelectComponent, [null, null, null, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TranslatedVocabularySelectComponent, "app-translated-vocabulary-select", never, { "label": { "alias": "label"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; "arbBindLabel": { "alias": "arbBindLabel"; "required": false; }; "engBindLabel": { "alias": "engBindLabel"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "hideSelectedItems": { "alias": "hideSelectedItems"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "clear": { "alias": "clear"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "useFilter": { "alias": "useFilter"; "required": false; }; "vocbularyId": { "alias": "vocbularyId"; "required": false; }; "mapingResponse": { "alias": "mapingResponse"; "required": false; }; "params": { "alias": "params"; "required": false; }; "getByDirectorySuggestion": { "alias": "getByDirectorySuggestion"; "required": false; }; }, { "onSelectItems": "onSelectItems"; }, never, never, false, never>;
+}

package/lib/components/vocabulary/vocabulary/vocabulary.component.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { UntypedFormControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { VocabularyApiService } from '../services/vocabulary-api.service';
+import * as i0 from "@angular/core";
+export declare class VocabularyComponent implements OnInit {
+    private vocabularyApi;
+    data: any[];
+    bindValue: any;
+    bindLabel: any;
+    placeholder: any;
+    multiple: boolean;
+    searchable: boolean;
+    closeOnSelect: boolean;
+    hideSelectedItems: boolean;
+    isAsync: boolean;
+    attachSource: boolean;
+    source$: Observable<any>;
+    hideLoaded: boolean;
+    vocabularyType: string;
+    onSelecting: EventEmitter<any>;
+    loading: boolean;
+    selection: any[];
+    propagateChange: any;
+    validateFn: any;
+    onTouched: any;
+    constructor(vocabularyApi: VocabularyApiService);
+    ngOnInit(): void;
+    getLisOfOptions(type: any): void;
+    getSelecteditems(selectedItems: any): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    validate(c: UntypedFormControl): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyComponent, "cts-vocabulary", never, { "bindValue": { "alias": "bindValue"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "hideSelectedItems": { "alias": "hideSelectedItems"; "required": false; }; "isAsync": { "alias": "isAsync"; "required": false; }; "attachSource": { "alias": "attachSource"; "required": false; }; "source$": { "alias": "source$"; "required": false; }; "hideLoaded": { "alias": "hideLoaded"; "required": false; }; "vocabularyType": { "alias": "vocabularyType"; "required": false; }; }, { "onSelecting": "onSelecting"; }, never, never, false, never>;
+}

package/lib/components/vocabulary/vocabulary.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./vocabulary/vocabulary.component";
+import * as i2 from "./translated-vocabulary-select/translated-vocabulary-select.component";
+import * as i3 from "@angular/common";
+import * as i4 from "../select/select.module";
+import * as i5 from "../dynamic-form/dynamic-form.module";
+import * as i6 from "@angular/forms";
+/** @ignore */
+export declare class VocabularyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VocabularyModule, [typeof i1.VocabularyComponent, typeof i2.TranslatedVocabularySelectComponent], [typeof i3.CommonModule, typeof i4.SelectModule, typeof i5.DynamicFormModule, typeof i6.FormsModule], [typeof i1.VocabularyComponent, typeof i2.TranslatedVocabularySelectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VocabularyModule>;
+}

package/lib/configuration/app-config.service.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from "@angular/common/http";
+import { ReplaySubject } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class AppConfigService {
+    private http;
+    constructor(http: HttpClient);
+    myConfiguration: any;
+    conditons: any;
+    theme: any;
+    configLoaded: ReplaySubject<unknown>;
+    load(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppConfigService>;
+}

package/lib/configuration/helpers/app-initializer.d.ts

@@ -0,0 +1,2 @@
+import { AppConfigService } from '../app-config.service';
+export declare function appInitializer(appConfigService: AppConfigService): Function;

package/lib/core/adapters/adapter.service.d.ts

@@ -0,0 +1,11 @@
+import { UtilityService } from '../utilities/utility.service';
+import * as i0 from "@angular/core";
+export declare class AdapterService {
+    private utiliService;
+    constructor(utiliService: UtilityService);
+    filterNullValues(formValue: any): {};
+    adaptIn(item: any, fieldsobj: any): any;
+    adaptOut(item: any, fieldsobj: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdapterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdapterService>;
+}

package/lib/core/core.module.d.ts

@@ -0,0 +1,16 @@
+import { ModuleWithProviders } from '@angular/core';
+import { Environment } from './env';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "legacy-ngx-treeview";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "ngx-toastr";
+import * as i5 from "keycloak-angular";
+import * as i6 from "@rxweb/reactive-form-validators";
+/** @ignore */
+export declare class NuxeoCoreModule {
+    static register(environment: Environment, configuration?: Record<string, any>, conditons?: Record<string, any>): ModuleWithProviders<NuxeoCoreModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NuxeoCoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NuxeoCoreModule, never, [typeof i1.CommonModule, typeof i2.TreeviewModule, typeof i3.TranslateModule, typeof i4.ToastrModule, typeof i5.KeycloakAngularModule, typeof i6.RxReactiveFormsModule], [typeof i5.KeycloakAngularModule, typeof i3.TranslateModule, typeof i2.TreeviewModule, typeof i4.ToastrModule, typeof i6.RxReactiveFormsModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NuxeoCoreModule>;
+}

package/lib/core/enums/language.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum Lang {
+    Arabic = "ar",
+    English = "en"
+}

package/lib/core/env/env-manager.d.ts

@@ -0,0 +1,54 @@
+export interface Environment {
+    [key: string]: any;
+    production?: boolean;
+    nuxeo?: string;
+    easyShare?: string;
+    mainFolder?: string;
+    customAutomation?: string;
+    create?: string;
+    documentContent?: string;
+    notifications?: string;
+    konfuzioIframeIP?: string;
+    commentsApi?: string;
+    clientName?: string;
+    showDocsTypesPage?: string;
+    showRetentionRule?: string;
+    showRegistrationMethod?: string;
+    externalShareEnabled?: string;
+    dmsDepRolePrefix?: string;
+    keycloak?: {
+        url?: string;
+        realm?: string;
+        clientId?: string;
+    };
+    RolesConstants?: {
+        [key: string]: string | undefined;
+    };
+    enableViewerWaterMark?: string;
+    enablePdfLinearization?: string;
+    pdftronLicenceKey?: string;
+    pdftronVideoLicenceKey?: string;
+    dynamsoftProductKey?: string;
+    enableRegisteration?: string;
+    enableSystemConfiguration?: string;
+    enableSearchNewDesign?: string;
+    enableSearchToggles?: string;
+    personScoreThreshold?: string;
+    officeEditAuthGrantMode?: string;
+    permanentMembership?: string;
+    maxFileSize?: number;
+    allowedFileTypes?: string;
+    allDepartmentFolders?: string;
+    showDocsValidationPage?: string;
+    showDataCatalogPage?: string;
+    enableDataCatalogConfiguration?: string;
+    faceRecognitionEnabled?: string;
+    configurationsUrl?: string;
+    showFooter?: string;
+}
+export declare class EnvManager {
+    static environment: Environment;
+    static configuration: Record<string, any>;
+    static conditons: Record<string, any>;
+    static initialize(values: Partial<Environment>): void;
+}

package/lib/core/env/index.d.ts

@@ -0,0 +1 @@
+export * from './env-manager';

package/lib/core/models/api-response.model.d.ts

@@ -0,0 +1,25 @@
+import { EntryModel, QuickFilter } from './base-response.models';
+export interface ApiResponseModel<TEntry extends Record<string, any> = EntryModel> {
+    'entity-type': string;
+    isPaginable: boolean;
+    resultsCount: number;
+    pageSize: number;
+    maxPageSize: number;
+    resultsCountLimit: number;
+    currentPageSize: number;
+    currentPageIndex: number;
+    currentPageOffset: number;
+    numberOfPages: number;
+    isPreviousPageAvailable: boolean;
+    isNextPageAvailable: boolean;
+    isLastPageAvailable: boolean;
+    isSortable: boolean;
+    hasError: boolean;
+    errorMessage: any;
+    totalSize?: number;
+    pageIndex: number;
+    pageCount: number;
+    quickFilters?: QuickFilter[];
+    entries: TEntry[];
+    aggregations?: Record<string, any>;
+}

package/lib/core/models/automation-response.model.d.ts

@@ -0,0 +1,24 @@
+import { SchemaModel } from "./base-response.models";
+export interface AutomationResponseModel<TProperties extends Record<string, any> = Record<PropertyKey, any>> {
+    'entity-type': string;
+    repository: string;
+    uid: string;
+    path: string;
+    type: string;
+    state: string;
+    parentRef: string;
+    isCheckedOut: boolean;
+    isRecord: boolean;
+    retainUntil: any;
+    hasLegalHold: boolean;
+    isUnderRetentionOrLegalHold: boolean;
+    isVersion: boolean;
+    isProxy: boolean;
+    changeToken: string;
+    isTrashed: boolean;
+    title: string;
+    lastModified: string;
+    properties?: TProperties;
+    facets: string[];
+    schemas: SchemaModel[];
+}

package/lib/core/models/base-response.models.d.ts

@@ -0,0 +1,12 @@
+export interface QuickFilter {
+    name: string;
+    active: boolean;
+}
+export interface EntryModel {
+    'entity-type': string;
+    state: string;
+}
+export interface SchemaModel {
+    name: string;
+    prefix: string;
+}

package/lib/core/models/component.model.d.ts

@@ -0,0 +1,6 @@
+export declare class ComponentTranslationModel {
+    name: string;
+    path: string;
+    json: string[];
+    constructor(obj?: any);
+}

package/lib/core/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-response.model';
+export * from './automation-response.model';
+export * from './base-response.models';
+export * from './component.model';

package/lib/core/services/callApi/call-api.service.d.ts

@@ -0,0 +1,19 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { NuxeoService } from '../nuxeo/nuxeo.service';
+import * as i0 from "@angular/core";
+export declare class CallApiService {
+    private nuxeoService;
+    private http;
+    private environment;
+    constructor(nuxeoService: NuxeoService, http: HttpClient, environment: any);
+    query(queryOptions: any, options: any): Observable<any>;
+    private inerQuery;
+    customQuery(query: {
+        url: string;
+        method: 'POST' | 'GET';
+        payload?: Record<string, any>;
+    }, params: Record<string, any>, headers?: Record<string, any>, body?: Record<string, any>): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CallApiService>;
+}

package/lib/core/services/column-renderer/column-renderer-registry.service.d.ts

@@ -0,0 +1,52 @@
+import { Type } from '@angular/core';
+import { ColumnTypeDefinition } from './types';
+import * as i0 from "@angular/core";
+export declare class ColumnRendererRegistryService {
+    private registry;
+    register(columns: ColumnTypeDefinition | ColumnTypeDefinition[]): void;
+    /**
+     * Retrieves a column type definition by its unique type key.
+     * @param type The column type identifier
+     */
+    get(type: string): ColumnTypeDefinition | undefined;
+    /**
+     * Returns all registered column type definitions.
+     */
+    getAll(): ColumnTypeDefinition[];
+    /**
+     * Gets column types filtered by app
+     */
+    getByApp(app: string): ColumnTypeDefinition[];
+    /**
+     * Returns only the component associated with a column type.
+     * @param type The column type identifier
+     */
+    getComponent(type: string): Type<unknown> | undefined;
+    /**
+     * Gets all column types filtered by category
+     */
+    getByCategory(category: string): ColumnTypeDefinition[];
+    /**
+     * Returns all unique categories
+     */
+    getCategories(): string[];
+    /**
+     * Returns column types grouped by category
+     */
+    getGroupedByCategory(): Record<string, ColumnTypeDefinition[]>;
+    /**
+     * Gets column types filtered by multiple categories
+     */
+    getByCategories(categories: string[]): ColumnTypeDefinition[];
+    /**
+     * Checks if a column type exists
+     */
+    has(type: string): boolean;
+    /**
+     * Clears all registered column types (mainly for testing or hot reload scenarios).
+     */
+    clear(): void;
+    private _set;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnRendererRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnRendererRegistryService>;
+}

package/lib/core/services/column-renderer/helpers.d.ts

@@ -0,0 +1,2 @@
+import { ColumnSchemaClassDefinition, ColumnTypeDefinition } from './types';
+export declare function createSchema<T extends ColumnSchemaClassDefinition>(col: T): ColumnTypeDefinition;

package/lib/core/services/column-renderer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './column-renderer-registry.service';
+export * from './types';
+export * from './helpers';

package/lib/core/services/column-renderer/types.d.ts

@@ -0,0 +1,25 @@
+import { Type } from '@angular/core';
+export type CategoryType = 'common' | 'custom';
+export interface ColumnSchemaClassDefinition {
+    new (...args: any[]): any;
+    getColumnMetadata(): ColumnTypeDefinition;
+}
+export interface ColumnTypeDefinition {
+    name: string;
+    type: string;
+    app?: string;
+    description?: string;
+    icon?: string;
+    component: Type<any>;
+    category: CategoryType;
+    options?: ComponentOptionDefinition[];
+}
+export type ComponentOptionDefinition = {
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'select' | 'textarea';
+    label: string;
+    defaultValue?: unknown;
+    options?: any[];
+    placeholder?: string;
+    required?: boolean;
+};

package/lib/core/services/extension/action.extensions.d.ts

@@ -0,0 +1,31 @@
+import { ExtensionElement } from './extension-element';
+export declare enum ContentActionType {
+    default = "default",
+    button = "button",
+    separator = "separator",
+    menu = "menu",
+    custom = "custom"
+}
+export interface ContentActionRef extends ExtensionElement {
+    type: ContentActionType;
+    title?: string;
+    description?: string;
+    icon?: string;
+    children?: Array<ContentActionRef>;
+    component?: string;
+    data?: any;
+    actions?: {
+        click?: string;
+        [key: string]: string;
+    };
+    rules?: {
+        enabled?: string;
+        visible?: string;
+        [key: string]: string;
+    };
+}
+export interface ActionRef {
+    id: string;
+    type: string;
+    payload?: any;
+}

package/lib/core/services/extension/component-register.service.d.ts

@@ -0,0 +1,20 @@
+import { Type } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ExtensionComponent {
+    data: any;
+}
+export declare class ComponentRegisterService {
+    components: {
+        [key: string]: Type<{}>;
+    };
+    setComponents(values: {
+        [key: string]: Type<{}>;
+    }): void;
+    getComponentById<T>(id: string): Type<T>;
+    hasComponentById(id: string): boolean;
+    getComponents(): {
+        [key: string]: Type<{}>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegisterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegisterService>;
+}

package/lib/core/services/extension/extenion-utils.d.ts

@@ -0,0 +1,14 @@
+import { ContentActionRef } from './action.extensions';
+export declare function getValue(target: any, key: string): any;
+export declare function filterEnabled(entry: {
+    disabled?: boolean;
+}): boolean;
+export declare function sortByOrder(a: {
+    order?: number | undefined;
+}, b: {
+    order?: number | undefined;
+}): number;
+export declare function reduceSeparators(acc: ContentActionRef[], el: ContentActionRef, i: number, arr: ContentActionRef[]): ContentActionRef[];
+export declare function reduceEmptyMenus(acc: ContentActionRef[], el: ContentActionRef): ContentActionRef[];
+export declare function mergeObjects(...objects: object[]): any;
+export declare function mergeArrays(left: any[], right: any[]): any[];

package/lib/core/services/extension/extension-element.d.ts

@@ -0,0 +1,5 @@
+export interface ExtensionElement {
+    id: string;
+    order?: number;
+    disabled?: boolean;
+}