@pepperi-addons/ngx-lib 0.4.2-beta.137 → 0.4.2-beta.139

package/query-builder/query-builder-item/query-builder-item.component.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { PepSmartFilterBaseField } from '@pepperi-addons/ngx-lib/smart-filters';
+import { IPepSmartFilterData } from '@pepperi-addons/ngx-lib/smart-filters';
+import { IPepOption } from '@pepperi-addons/ngx-lib';
+import { PepTypeConvertorService } from '../common/services/type-convertor.service';
+import { IPepQueryBuilderFieldContainer } from '../common/model/field';
+import * as i0 from "@angular/core";
+export declare class PepQueryBuilderItemComponent {
+    private _fb;
+    typeConvertorService: PepTypeConvertorService;
+    formKey: string;
+    _fields: Array<IPepQueryBuilderFieldContainer>;
+    _options: IPepOption[];
+    set fields(list: Array<IPepQueryBuilderFieldContainer>);
+    _selectedField: PepSmartFilterBaseField;
+    set selected(value: IPepQueryBuilderFieldContainer);
+    _filter: IPepSmartFilterData;
+    set filter(value: IPepSmartFilterData);
+    _parentForm: FormGroup;
+    set parentForm(value: FormGroup);
+    variableFields: any;
+    filterChange: EventEmitter<any>;
+    remove: EventEmitter<any>;
+    form: FormGroup;
+    constructor(_fb: FormBuilder, typeConvertorService: PepTypeConvertorService);
+    ngOnInit(): void;
+    get f(): {
+        [key: string]: import("@angular/forms").AbstractControl<any, any>;
+    };
+    get queryForm(): {
+        [key: string]: import("@angular/forms").AbstractControl<any, any>;
+    };
+    setupForm(): void;
+    addToParentForm(): void;
+    onFieldChanged(key: any): void;
+    onFilterChanged(): void;
+    onDeleteItemClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepQueryBuilderItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepQueryBuilderItemComponent, "pep-query-builder-item", never, { "formKey": "formKey"; "fields": "fields"; "selected": "selected"; "filter": "filter"; "parentForm": "parentForm"; "variableFields": "variableFields"; }, { "filterChange": "filterChange"; "remove": "remove"; }, never, never, false>;
+}

package/query-builder/query-builder-section/query-builder-section.component.d.ts

@@ -0,0 +1,30 @@
+import { EventEmitter, ViewContainerRef } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { PepButton } from '@pepperi-addons/ngx-lib/button';
+import { PepTypeConvertorService } from '../common/services/type-convertor.service';
+import { IPepQueryDepth } from '../common/model/structure';
+import * as i0 from "@angular/core";
+export declare class PepQueryBuilderSectionComponent {
+    private _typeConvertorService;
+    form: FormGroup;
+    depth: IPepQueryDepth;
+    hasFields: boolean;
+    createSection: EventEmitter<any>;
+    createItem: EventEmitter<any>;
+    remove: EventEmitter<any>;
+    operatorChange: EventEmitter<any>;
+    sectionContainer: ViewContainerRef;
+    toggleButtons: Array<PepButton>;
+    constructor(_typeConvertorService: PepTypeConvertorService);
+    ngOnInit(): void;
+    get f(): {
+        [key: string]: import("@angular/forms").AbstractControl<any, any>;
+    };
+    initOperators(): void;
+    onOperatorChanged(event: any): void;
+    onAddRuleClicked(): void;
+    onAddRuleSetClicked(): void;
+    onDeleteSectionClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepQueryBuilderSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepQueryBuilderSectionComponent, "pep-query-builder-section", never, { "form": "form"; "depth": "depth"; "hasFields": "hasFields"; }, { "createSection": "createSection"; "createItem": "createItem"; "remove": "remove"; "operatorChange": "operatorChange"; }, never, never, false>;
+}

package/query-builder/query-builder.component.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter, OnInit, OnDestroy } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+import { PepQueryBuilderSectionComponent } from './query-builder-section/query-builder-section.component';
+import { IPepQueryBuilderField, IPepQuerySection, IPepQueryItem } from './common/model/legacy';
+import { PepQueryStructureService } from './common/services/query-structure.service';
+import { IPepQueryDepth } from './common/model/structure';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class PepQueryBuilderComponent implements OnInit, OnDestroy {
+    private _fb;
+    queryStructureService: PepQueryStructureService;
+    _query: IPepQuerySection | IPepQueryItem;
+    set query(object: IPepQuerySection | IPepQueryItem);
+    set fields(list: Array<IPepQueryBuilderField>);
+    set variableFields(list: Array<IPepQueryBuilderField>);
+    set maxDepth(value: number);
+    queryChange: EventEmitter<IPepQuerySection | IPepQueryItem>;
+    formValidationChange: EventEmitter<boolean>;
+    root: PepQueryBuilderSectionComponent;
+    _formSubscription$: Subscription;
+    _outputQuerySubscription$: Subscription;
+    _lastFormValidStatus: boolean;
+    depth: IPepQueryDepth;
+    hasFields: boolean;
+    constructor(_fb: FormBuilder, queryStructureService: PepQueryStructureService);
+    ngOnInit(): void;
+    setupForm(): void;
+    initDepth(): void;
+    /**
+     * builds UI query structure as soon as both the fields and query loads
+     */
+    loadQuery(): void;
+    onCreateSection(): void;
+    onCreateItem(): void;
+    onOperatorChange(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepQueryBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepQueryBuilderComponent, "pep-query-builder", never, { "query": "query"; "fields": "fields"; "variableFields": "variableFields"; "maxDepth": "maxDepth"; }, { "queryChange": "queryChange"; "formValidationChange": "formValidationChange"; }, never, never, false>;
+}

package/query-builder/query-builder.module.d.ts

@@ -0,0 +1,20 @@
+import { PepIconRegistry } from '@pepperi-addons/ngx-lib/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "./query-builder.component";
+import * as i2 from "./query-builder-section/query-builder-section.component";
+import * as i3 from "./query-builder-item/query-builder-item.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/flex-layout";
+import * as i7 from "@pepperi-addons/ngx-lib/select";
+import * as i8 from "@pepperi-addons/ngx-lib/button";
+import * as i9 from "@pepperi-addons/ngx-lib/icon";
+import * as i10 from "@pepperi-addons/ngx-lib/group-buttons";
+import * as i11 from "@pepperi-addons/ngx-lib/smart-filters";
+export declare class PepQueryBuilderModule {
+    private pepIconRegistry;
+    constructor(pepIconRegistry: PepIconRegistry);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepQueryBuilderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PepQueryBuilderModule, [typeof i1.PepQueryBuilderComponent, typeof i2.PepQueryBuilderSectionComponent, typeof i3.PepQueryBuilderItemComponent], [typeof i4.CommonModule, typeof i5.ReactiveFormsModule, typeof i6.FlexLayoutModule, typeof i7.PepSelectModule, typeof i8.PepButtonModule, typeof i9.PepIconModule, typeof i10.PepGroupButtonsModule, typeof i11.PepSmartFiltersModule], [typeof i1.PepQueryBuilderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PepQueryBuilderModule>;
+}

package/query-builder/query-builder.service.d.ts

@@ -0,0 +1,30 @@
+import { IPepQueryBuilderField, IPepQueryItem } from './common/model/legacy';
+import { IPepSmartFilterData, PepSmartFilterBaseField } from '@pepperi-addons/ngx-lib/smart-filters';
+import { IPepQueryBuilderFieldContainer } from './common/model/field';
+import * as i0 from "@angular/core";
+export declare class PepQueryBuilderService {
+    constructor();
+    /**
+     * creates a smart filter object
+     * @param current filter legacy element
+     * @param field filter's selected field
+     * @returns smart filter object
+     */
+    getFilter(current: IPepQueryItem, field: PepSmartFilterBaseField): IPepSmartFilterData | null;
+    /**
+     * converts legacy fields to smart filter fields
+     * @param fields legacy fields array
+     * @returns smart filter fields array
+     */
+    convertToSmartFilterFields(fields: Array<IPepQueryBuilderField>): Array<IPepQueryBuilderFieldContainer>;
+    /**
+     * gets smart filter's values data
+     * @param current filter legacy element
+     * @param operator smart filter operator
+     * @param field filter's selected field
+     * @returns object contains the filter values data
+     */
+    private getFilterValues;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepQueryBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PepQueryBuilderService>;
+}

package/remote-loader/addon-block-loader.component.d.ts

@@ -0,0 +1,36 @@
+import { OnInit, EventEmitter, TemplateRef, OnDestroy } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { PepRemoteLoaderOptions } from './remote-loader.model';
+import { PepRemoteLoaderService } from './remote-loader.service';
+import * as i0 from "@angular/core";
+export declare class PepAddonBlockLoaderComponent implements OnInit, OnDestroy {
+    private remoteLoaderService;
+    dialogTemplate: TemplateRef<any>;
+    addonId: string;
+    remoteEntry: string;
+    slugName: string;
+    private _blockType;
+    set blockType(value: string);
+    get blockType(): string;
+    private _name;
+    set name(value: string);
+    get name(): string;
+    hostObject: any;
+    private _dialogRef;
+    set dialogRef(value: MatDialogRef<any>);
+    get dialogRef(): MatDialogRef<any>;
+    hostEvents: EventEmitter<any>;
+    blockLoad: EventEmitter<void>;
+    protected inDialog: boolean;
+    protected remotePathOptions: PepRemoteLoaderOptions;
+    protected loadElement: boolean;
+    protected onHostEventsCallback: (event: CustomEvent) => void;
+    constructor(remoteLoaderService: PepRemoteLoaderService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onBlockLoad(): void;
+    onHostEvents(event: any): void;
+    closeDialog(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepAddonBlockLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepAddonBlockLoaderComponent, "pep-addon-block-loader", never, { "addonId": "addonId"; "remoteEntry": "remoteEntry"; "slugName": "slugName"; "blockType": "blockType"; "name": "name"; "hostObject": "hostObject"; "dialogRef": "dialogRef"; }, { "hostEvents": "hostEvents"; "blockLoad": "blockLoad"; }, never, never, false>;
+}

package/remote-loader/addon-block-loader.service.d.ts

@@ -0,0 +1,15 @@
+import { ComponentRef } from '@angular/core';
+import { IAddonBlockLoaderDialogOptions, IAddonBlockLoaderOptions } from './remote-loader.model';
+import { PepAddonBlockLoaderComponent } from './addon-block-loader.component';
+import { MatDialogRef } from '@angular/material/dialog';
+import { PepDialogService } from '@pepperi-addons/ngx-lib/dialog';
+import * as i0 from "@angular/core";
+export declare class PepAddonBlockLoaderService {
+    private dialogService;
+    constructor(dialogService: PepDialogService);
+    private loadAddonBlockInternal;
+    loadAddonBlockInContainer(options: IAddonBlockLoaderOptions): ComponentRef<PepAddonBlockLoaderComponent> | null;
+    loadAddonBlockInDialog(options: IAddonBlockLoaderDialogOptions): MatDialogRef<any> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepAddonBlockLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PepAddonBlockLoaderService>;
+}

package/remote-loader/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@pepperi-addons/ngx-lib/remote-loader" />
+export * from './public-api';

package/remote-loader/public-api.d.ts

@@ -0,0 +1,7 @@
+export * from './addon-block-loader.component';
+export * from './addon-block-loader.service';
+export * from './remote-loader.component';
+export * from './remote-loader-element.component';
+export * from './remote-loader.module';
+export * from './remote-loader.model';
+export * from './remote-loader.service';

package/remote-loader/remote-loader-element.component.d.ts

@@ -0,0 +1,32 @@
+import { AfterContentInit, ElementRef, EventEmitter, OnChanges, OnDestroy, Renderer2 } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { PepAddonService } from '@pepperi-addons/ngx-lib';
+import { PepRemoteLoaderOptions } from './remote-loader.model';
+import { PepRemoteLoaderService } from './remote-loader.service';
+import * as i0 from "@angular/core";
+export declare class PepRemoteLoaderElementComponent implements AfterContentInit, OnChanges, OnDestroy {
+    private renderer;
+    private el;
+    private pepAddonService;
+    private remoteLoaderService;
+    private route;
+    options: PepRemoteLoaderOptions;
+    props: {
+        [prop: string]: unknown;
+    };
+    events: {
+        [event: string]: (event: Event) => void;
+    };
+    load: EventEmitter<any>;
+    element: HTMLElement;
+    private _elementName;
+    constructor(renderer: Renderer2, el: ElementRef, pepAddonService: PepAddonService, remoteLoaderService: PepRemoteLoaderService, route: ActivatedRoute);
+    private populateProps;
+    private setupEvents;
+    private loadOptionsFromRoute;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepRemoteLoaderElementComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepRemoteLoaderElementComponent, "pep-remote-loader-element", never, { "options": "options"; "props": "props"; "events": "events"; }, { "load": "load"; }, never, never, false>;
+}

package/remote-loader/remote-loader.component.d.ts

@@ -0,0 +1,25 @@
+import { OnChanges, ViewContainerRef, Injector, EventEmitter, SimpleChanges } from '@angular/core';
+import { PepAddonService } from '@pepperi-addons/ngx-lib';
+import { PepRemoteLoaderOptions } from './remote-loader.model';
+import * as i0 from "@angular/core";
+export declare class PepRemoteLoaderComponent implements OnChanges {
+    private injector;
+    private pepAddonService;
+    viewContainer: ViewContainerRef;
+    private _options;
+    set options(value: PepRemoteLoaderOptions);
+    get options(): PepRemoteLoaderOptions;
+    private _hostObject;
+    set hostObject(value: any);
+    get hostObject(): any;
+    hostEvents: EventEmitter<any>;
+    load: EventEmitter<any>;
+    private compRef;
+    constructor(injector: Injector, pepAddonService: PepAddonService);
+    private setHostComponentIntoComponentRef;
+    ngOnChanges(changes: SimpleChanges): void;
+    private loadModule;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepRemoteLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepRemoteLoaderComponent, "pep-remote-loader", never, { "options": "options"; "hostObject": "hostObject"; }, { "hostEvents": "hostEvents"; "load": "load"; }, never, never, false>;
+}

package/remote-loader/remote-loader.model.d.ts

@@ -0,0 +1,41 @@
+import { LoadRemoteModuleOptions } from "@angular-architects/module-federation";
+import { ViewContainerRef } from "@angular/core";
+import { MatDialogConfig } from "@angular/material/dialog";
+import { PepDialogSizeType } from "@pepperi-addons/ngx-lib/dialog";
+import { InstalledAddon, NgComponentRelation } from "@pepperi-addons/papi-sdk";
+declare type PepRemoteLoaderData = {
+    addonId?: string;
+    componentName?: string;
+    elementName?: string;
+};
+export declare type PepRemoteLoaderOptions = PepRemoteLoaderData & LoadRemoteModuleOptions;
+export interface IPepRemoteLoaderParamsOptions {
+    name?: string;
+    slugName?: string;
+    blockType?: string;
+    addonUUID?: string;
+    blockRemoteEntry?: string;
+    pagesDevServer?: string;
+}
+export interface IBlockLoaderData {
+    relation: NgComponentRelation;
+    addon?: InstalledAddon;
+    addonPublicBaseURL: string;
+}
+export interface IAddonBlockLoaderOptions extends IPepRemoteLoaderParamsOptions {
+    container: ViewContainerRef;
+    hostObject?: any;
+    hostEventsCallback?: (event: any) => void;
+}
+export interface IAddonBlockLoaderDialogOptions extends IAddonBlockLoaderOptions {
+    data?: IAddonBlockLoaderDialogDataOptions;
+    config?: MatDialogConfig;
+    size?: PepDialogSizeType;
+}
+export interface IAddonBlockLoaderDialogDataOptions {
+    title?: string;
+    showClose?: boolean;
+    showHeader?: boolean;
+    showFooter?: boolean;
+}
+export {};

package/remote-loader/remote-loader.module.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./addon-block-loader.component";
+import * as i2 from "./remote-loader.component";
+import * as i3 from "./remote-loader-element.component";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/common/http";
+import * as i6 from "@angular-architects/module-federation-tools";
+import * as i7 from "@angular/material/dialog";
+import * as i8 from "@pepperi-addons/ngx-lib";
+import * as i9 from "@pepperi-addons/ngx-lib/dialog";
+export declare class PepRemoteLoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepRemoteLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PepRemoteLoaderModule, [typeof i1.PepAddonBlockLoaderComponent, typeof i2.PepRemoteLoaderComponent, typeof i3.PepRemoteLoaderElementComponent], [typeof i4.CommonModule, typeof i5.HttpClientModule, typeof i6.ModuleFederationToolsModule, typeof i7.MatDialogModule, typeof i8.PepNgxLibModule, typeof i9.PepDialogModule], [typeof i1.PepAddonBlockLoaderComponent, typeof i2.PepRemoteLoaderComponent, typeof i3.PepRemoteLoaderElementComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PepRemoteLoaderModule>;
+}

package/remote-loader/remote-loader.service.d.ts

@@ -0,0 +1,15 @@
+import { PepAddonService, PepHttpService, PepSessionService } from '@pepperi-addons/ngx-lib';
+import { IPepRemoteLoaderParamsOptions, PepRemoteLoaderOptions } from './remote-loader.model';
+import { IBlockLoaderData } from './remote-loader.model';
+import * as i0 from "@angular/core";
+export declare class PepRemoteLoaderService {
+    private httpService;
+    private sessionService;
+    private addonService;
+    constructor(httpService: PepHttpService, sessionService: PepSessionService, addonService: PepAddonService);
+    private getBlockLoaderDataUrl;
+    getRemoteLoaderOptions(blockLoaderData: IBlockLoaderData, blockRemoteEntry?: string, type?: 'script' | 'module' | 'manifest'): PepRemoteLoaderOptions;
+    getBlockRemoteLoaderOptions(options: IPepRemoteLoaderParamsOptions): Promise<PepRemoteLoaderOptions>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepRemoteLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PepRemoteLoaderService>;
+}

package/rich-html-textarea/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@pepperi-addons/ngx-lib/rich-html-textarea" />
+export * from './public-api';

package/rich-html-textarea/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './rich-html-textarea.module';
+export * from './rich-html-textarea.component';

package/rich-html-textarea/rich-html-textarea.component.d.ts

@@ -0,0 +1,80 @@
+import { OnInit, EventEmitter, OnDestroy, ElementRef, Renderer2, TemplateRef, OnChanges } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { PepLayoutType, PepCustomizationService, PepHorizontalAlignment } from '@pepperi-addons/ngx-lib';
+import { PepDialogService } from '@pepperi-addons/ngx-lib/dialog';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export interface IPepRichHtmlTextareaToolbarOptions {
+    font?: any;
+    size?: any;
+    header?: any;
+    bold?: any;
+    italic?: any;
+    underline?: any;
+    strike?: any;
+    link?: any;
+    image?: any;
+    ordered?: any;
+    bullet?: any;
+    color?: any;
+    background?: any;
+    align?: any;
+}
+export declare class PepRichHtmlTextareaComponent implements OnInit, OnChanges, OnDestroy {
+    private sanitizer;
+    private dialogService;
+    private customizationService;
+    private renderer;
+    private element;
+    key: string;
+    value: string;
+    label: string;
+    mandatory: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    maxFieldCharacters: number;
+    xAlignment: PepHorizontalAlignment;
+    sanitize: true;
+    private _rowSpan;
+    set rowSpan(value: number);
+    get rowSpan(): number;
+    private _visible;
+    set visible(visible: boolean);
+    get visible(): boolean;
+    controlType: string;
+    form: FormGroup;
+    isActive: boolean;
+    showTitle: boolean;
+    renderTitle: boolean;
+    renderEnlargeButton: boolean;
+    private _layoutType;
+    set layoutType(value: PepLayoutType);
+    get layoutType(): PepLayoutType;
+    inlineMode: boolean;
+    protected _toolbarOptions: IPepRichHtmlTextareaToolbarOptions;
+    get toolbarOptions(): IPepRichHtmlTextareaToolbarOptions;
+    set toolbarOptions(options: IPepRichHtmlTextareaToolbarOptions);
+    valueChange: EventEmitter<string>;
+    richTextEditorDialogTemplate: TemplateRef<any>;
+    quillContent: string;
+    quillContentDialog: string;
+    fieldHeight: string;
+    standAlone: boolean;
+    active: boolean;
+    constructor(sanitizer: DomSanitizer, dialogService: PepDialogService, customizationService: PepCustomizationService, renderer: Renderer2, element: ElementRef);
+    private setFieldHeight;
+    private setDefaultForm;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    getDefaultToolbarOptions(): IPepRichHtmlTextareaToolbarOptions;
+    changeValue(value: any): void;
+    cardTemplateClicked(event: any): void;
+    openDialog(): void;
+    onEditorCreated(quill: any, inDialog: boolean): void;
+    onContentChanged(obj: any, inDialog: boolean): void;
+    onBlur(obj: any, inDialog: boolean): void;
+    onFocus(obj: any, inDialog: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepRichHtmlTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepRichHtmlTextareaComponent, "pep-rich-html-textarea", never, { "key": "key"; "value": "value"; "label": "label"; "mandatory": "mandatory"; "disabled": "disabled"; "readonly": "readonly"; "maxFieldCharacters": "maxFieldCharacters"; "xAlignment": "xAlignment"; "sanitize": "sanitize"; "rowSpan": "rowSpan"; "visible": "visible"; "form": "form"; "isActive": "isActive"; "showTitle": "showTitle"; "renderTitle": "renderTitle"; "renderEnlargeButton": "renderEnlargeButton"; "layoutType": "layoutType"; "inlineMode": "inlineMode"; "toolbarOptions": "toolbarOptions"; }, { "valueChange": "valueChange"; }, never, never, false>;
+}

package/rich-html-textarea/rich-html-textarea.module.d.ts

@@ -0,0 +1,25 @@
+import { PepIconRegistry } from '@pepperi-addons/ngx-lib/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "./rich-html-textarea.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/core";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@angular/material/input";
+import * as i8 from "@angular/material/menu";
+import * as i9 from "@angular/material/icon";
+import * as i10 from "@angular/material/dialog";
+import * as i11 from "ngx-quill";
+import * as i12 from "@pepperi-addons/ngx-lib";
+import * as i13 from "@pepperi-addons/ngx-lib/icon";
+import * as i14 from "@pepperi-addons/ngx-lib/field-title";
+import * as i15 from "@pepperi-addons/ngx-lib/textbox-icon";
+import * as i16 from "@pepperi-addons/ngx-lib/dialog";
+export declare class PepRichHtmlTextareaModule {
+    private pepIconRegistry;
+    constructor(pepIconRegistry: PepIconRegistry);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepRichHtmlTextareaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PepRichHtmlTextareaModule, [typeof i1.PepRichHtmlTextareaComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i3.FormsModule, typeof i4.MatCommonModule, typeof i5.MatButtonModule, typeof i6.MatFormFieldModule, typeof i7.MatInputModule, typeof i8.MatMenuModule, typeof i9.MatIconModule, typeof i10.MatDialogModule, typeof i11.QuillModule, typeof i12.PepNgxLibModule, typeof i13.PepIconModule, typeof i14.PepFieldTitleModule, typeof i15.PepTextboxIconModule, typeof i16.PepDialogModule], [typeof i1.PepRichHtmlTextareaComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PepRichHtmlTextareaModule>;
+}

package/search/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@pepperi-addons/ngx-lib/search" />
+export * from './public-api';

package/search/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './search.module';
+export * from './search.model';
+export * from './search.component';

package/search/search.component.d.ts

@@ -0,0 +1,65 @@
+import { OnInit, OnDestroy, EventEmitter, ElementRef } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { PepLayoutService, PepScreenSizeType, PepSizeType } from '@pepperi-addons/ngx-lib';
+import { IPepSearchClickEvent, IPepSearchAutocompleteChangeEvent, IPepSearchStateChangeEvent, PepSearchType, PepSearchTriggerType, PepSearchShrinkType } from './search.model';
+import * as i0 from "@angular/core";
+export declare class PepSearchComponent implements OnInit, OnDestroy {
+    private hostElement;
+    private layoutService;
+    triggerOn: PepSearchTriggerType;
+    autoCompleteTop: number;
+    private _autoCompleteValues;
+    set autoCompleteValues(val: any[]);
+    get autoCompleteValues(): any[];
+    private _shrink;
+    set shrink(value: PepSearchShrinkType);
+    get shrink(): PepSearchShrinkType;
+    set value(val: string);
+    get value(): string;
+    private _searchControl;
+    set searchControl(ctrl: FormControl);
+    get searchControl(): FormControl;
+    private _useAsWebComponent;
+    set useAsWebComponent(value: boolean);
+    get useAsWebComponent(): boolean;
+    /**
+     * The size of the button.
+     *
+     * @type {PepSizeType}
+     * @memberof PepButtonComponent
+     */
+    sizeType: PepSizeType;
+    search: EventEmitter<IPepSearchClickEvent>;
+    autocompleteChange: EventEmitter<IPepSearchAutocompleteChangeEvent>;
+    stateChange: EventEmitter<IPepSearchStateChangeEvent>;
+    searchInput: ElementRef;
+    private readonly _destroyed;
+    type: PepSearchType;
+    fadeState: 'fadeOut' | 'fadeIn';
+    state: 'open' | 'close';
+    lastValue: any;
+    showFloatSrcBtn: boolean;
+    isRtl: boolean;
+    isFloating: boolean;
+    screenSize: PepScreenSizeType;
+    constructor(hostElement: ElementRef, layoutService: PepLayoutService);
+    private setIsFloating;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private exportFunctionsOnHostElement;
+    private createSearchControlIfNotExist;
+    private blur;
+    private showFloatingButton;
+    initSearch(): void;
+    onClearClicked(event: any): void;
+    onSearchClicked(): void;
+    onFocusout(): void;
+    onSearch(event: Event): void;
+    triggerSearch(): void;
+    animateSearch(): void;
+    animateSearchDone(): void;
+    emitSearchClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepSearchComponent, "pep-search", never, { "triggerOn": "triggerOn"; "autoCompleteTop": "autoCompleteTop"; "autoCompleteValues": "autoCompleteValues"; "shrink": "shrink"; "value": "value"; "searchControl": "searchControl"; "useAsWebComponent": "useAsWebComponent"; "sizeType": "sizeType"; }, { "search": "search"; "autocompleteChange": "autocompleteChange"; "stateChange": "stateChange"; }, never, never, false>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PepSearchComponent>;
+}

package/search/search.model.d.ts

@@ -0,0 +1,14 @@
+export declare type PepSearchType = 'regular' | 'auto-complete';
+export declare type PepSearchTriggerType = 'keydown' | 'click';
+export declare type PepSearchStateType = 'open' | 'close';
+export declare type PepSearchShrinkType = 'small-screen' | 'always' | 'never';
+export interface IPepSearchClickEvent {
+    value: string;
+}
+export interface IPepSearchAutocompleteChangeEvent {
+    value: string;
+    top: number;
+}
+export interface IPepSearchStateChangeEvent {
+    state: PepSearchStateType;
+}

package/search/search.module.d.ts

@@ -0,0 +1,20 @@
+import { PepIconRegistry } from '@pepperi-addons/ngx-lib/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "./search.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/core";
+import * as i5 from "@angular/material/autocomplete";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/form-field";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@pepperi-addons/ngx-lib";
+import * as i10 from "@pepperi-addons/ngx-lib/icon";
+import * as i11 from "@angular/material/input";
+export declare class PepSearchModule {
+    private pepIconRegistry;
+    constructor(pepIconRegistry: PepIconRegistry);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepSearchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PepSearchModule, [typeof i1.PepSearchComponent], [typeof i2.CommonModule, typeof i3.ReactiveFormsModule, typeof i4.MatCommonModule, typeof i5.MatAutocompleteModule, typeof i6.MatButtonModule, typeof i7.MatFormFieldModule, typeof i8.MatIconModule, typeof i9.PepNgxLibModule, typeof i10.PepIconModule, typeof i11.MatInputModule], [typeof i1.PepSearchComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PepSearchModule>;
+}

package/select/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@pepperi-addons/ngx-lib/select" />
+export * from './public-api';

package/select/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './select.module';
+export * from './select.component';