primeng 0.0.0-watch

package/organizationchart/index.d.ts

@@ -0,0 +1,285 @@
+import * as rxjs from 'rxjs';
+import { Subscription } from 'rxjs';
+import * as i0 from '@angular/core';
+import { TemplateRef, OnDestroy, ChangeDetectorRef, AfterContentInit, ElementRef, EventEmitter, QueryList } from '@angular/core';
+import * as i1 from 'primeng/api';
+import { TreeNode, PrimeTemplate } from 'primeng/api';
+import { BaseComponent } from 'primeng/basecomponent';
+import { Nullable } from 'primeng/ts-helpers';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primeng/base';
+
+/**
+ * Custom node select event.
+ * @see {@link OrganizationChart.onNodeSelect}
+ * @group Events
+ */
+interface OrganizationChartNodeSelectEvent {
+    /**
+     * Browser event.
+     */
+    originalEvent: Event;
+    /**
+     * Node instance.
+     */
+    node: TreeNode;
+}
+/**
+ * Custom node unselect event.
+ * @see {@link OrganizationChart.onNodeUnSelect}
+ * @extends {OrganizationChartNodeSelectEvent}
+ * @group Events
+ */
+interface OrganizationChartNodeUnSelectEvent extends OrganizationChartNodeSelectEvent {
+}
+/**
+ * Custom node expand event.
+ * @see {@link OrganizationChart.onNodeExpand}
+ * @extends {OrganizationChartNodeSelectEvent}
+ * @group Events
+ */
+interface OrganizationChartNodeExpandEvent extends OrganizationChartNodeSelectEvent {
+}
+/**
+ * Custom node collapse event.
+ * @see {@link OrganizationChart.onNodeCollapse}
+ * @extends {OrganizationChartNodeSelectEvent}
+ * @group Events
+ */
+interface OrganizationChartNodeCollapseEvent extends OrganizationChartNodeSelectEvent {
+}
+/**
+ * Defines valid templates in OrganizationChart.
+ * @group Templates
+ */
+interface OrganizationChartTemplates {
+    /**
+     * Custom toggler icon template.
+     * @param {Object} context - item data.
+     */
+    togglericon(context: {
+        /**
+         * Expanded state of the node.
+         */
+        $implicit: boolean;
+    }): TemplateRef<{
+        $implicit: boolean;
+    }>;
+}
+
+/**
+ *
+ * OrganizationChart visualizes hierarchical organization data.
+ *
+ * [Live Demo](https://www.primeng.org/organizationchart)
+ *
+ * @module organizationchartstyle
+ *
+ */
+declare enum OrganizationChartClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-organizationchart",
+    /**
+     * Class name of the table element
+     */
+    table = "p-organizationchart-table",
+    /**
+     * Class name of the node element
+     */
+    node = "p-organizationchart-node",
+    /**
+     * Class name of the node toggle button element
+     */
+    nodeToggleButton = "p-organizationchart-node-toggle-button",
+    /**
+     * Class name of the node toggle button icon element
+     */
+    nodeToggleButtonIcon = "p-organizationchart-node-toggle-button-icon",
+    /**
+     * Class name of the connectors element
+     */
+    connectors = "p-organizationchart-connectors",
+    /**
+     * Class name of the connector down element
+     */
+    connectorDown = "p-organizationchart-connector-down",
+    /**
+     * Class name of the connector left element
+     */
+    connectorLeft = "p-organizationchart-connector-left",
+    /**
+     * Class name of the connector right element
+     */
+    connectorRight = "p-organizationchart-connector-right",
+    /**
+     * Class name of the node children element
+     */
+    nodeChildren = "p-organizationchart-node-children"
+}
+declare class OrganizationChartStyle extends BaseStyle {
+    name: string;
+    theme: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-organizationchart-preservespace': any;
+        })[];
+        table: string;
+        node: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-organizationchart-node': boolean;
+            'p-organizationchart-node-selectable': boolean;
+            'p-organizationchart-node-selected': any;
+        })[];
+        nodeToggleButton: string;
+        nodeToggleButtonIcon: string;
+        connectors: string;
+        connectorDown: string;
+        connectorLeft: ({ first }: {
+            first: any;
+        }) => (string | {
+            'p-organizationchart-connector-top': boolean;
+        })[];
+        connectorRight: ({ last }: {
+            last: any;
+        }) => (string | {
+            'p-organizationchart-connector-top': boolean;
+        })[];
+        nodeChildren: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationChartStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OrganizationChartStyle>;
+}
+interface OrganizationChartStyle extends BaseStyle {
+}
+
+declare class OrganizationChartNode extends BaseComponent implements OnDestroy {
+    cd: ChangeDetectorRef;
+    node: TreeNode<any> | undefined;
+    root: boolean | undefined;
+    first: boolean | undefined;
+    last: boolean | undefined;
+    collapsible: boolean | undefined;
+    chart: OrganizationChart;
+    subscription: Subscription;
+    _componentStyle: OrganizationChartStyle;
+    constructor(chart: OrganizationChart, cd: ChangeDetectorRef);
+    get leaf(): boolean | undefined;
+    get colspan(): number;
+    getChildStyle(node: TreeNode<any>): {
+        visibility: string;
+    };
+    onNodeClick(event: Event, node: TreeNode): void;
+    toggleNode(event: Event, node: TreeNode): void;
+    isSelected(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationChartNode, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OrganizationChartNode, "[pOrganizationChartNode]", never, { "node": { "alias": "node"; "required": false; }; "root": { "alias": "root"; "required": false; }; "first": { "alias": "first"; "required": false; }; "last": { "alias": "last"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_root: unknown;
+    static ngAcceptInputType_first: unknown;
+    static ngAcceptInputType_last: unknown;
+    static ngAcceptInputType_collapsible: unknown;
+}
+/**
+ * OrganizationChart visualizes hierarchical organization data.
+ * @group Components
+ */
+declare class OrganizationChart extends BaseComponent implements AfterContentInit {
+    el: ElementRef;
+    cd: ChangeDetectorRef;
+    /**
+     * An array of nested TreeNodes.
+     * @group Props
+     */
+    value: TreeNode[] | undefined;
+    /**
+     * Style class of the component.
+     * @deprecated since v20.0.0, use `class` instead.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Defines the selection mode.
+     * @group Props
+     */
+    selectionMode: 'single' | 'multiple' | null | undefined;
+    /**
+     * Whether the nodes can be expanded or toggled.
+     * @group Props
+     */
+    collapsible: boolean | undefined;
+    /**
+     * Whether the space allocated by a node is preserved when hidden.
+     * @deprecated since v20.0.0.
+     * @group Props
+     */
+    preserveSpace: boolean;
+    /**
+     * A single treenode instance or an array to refer to the selections.
+     * @group Props
+     */
+    get selection(): any;
+    set selection(val: any);
+    /**
+     * Callback to invoke on selection change.
+     * @param {*} any - selected value.
+     * @group Emits
+     */
+    selectionChange: EventEmitter<any>;
+    /**
+     * Callback to invoke when a node is selected.
+     * @param {OrganizationChartNodeSelectEvent} event - custom node select event.
+     * @group Emits
+     */
+    onNodeSelect: EventEmitter<OrganizationChartNodeSelectEvent>;
+    /**
+     * Callback to invoke when a node is unselected.
+     * @param {OrganizationChartNodeUnSelectEvent} event - custom node unselect event.
+     * @group Emits
+     */
+    onNodeUnselect: EventEmitter<OrganizationChartNodeUnSelectEvent>;
+    /**
+     * Callback to invoke when a node is expanded.
+     * @param {OrganizationChartNodeExpandEvent} event - custom node expand event.
+     * @group Emits
+     */
+    onNodeExpand: EventEmitter<OrganizationChartNodeExpandEvent>;
+    /**
+     * Callback to invoke when a node is collapsed.
+     * @param {OrganizationChartNodeCollapseEvent} event - custom node collapse event.
+     * @group Emits
+     */
+    onNodeCollapse: EventEmitter<OrganizationChartNodeCollapseEvent>;
+    templates: Nullable<QueryList<PrimeTemplate>>;
+    togglerIconTemplate: TemplateRef<any> | undefined;
+    templateMap: any;
+    _togglerIconTemplate: Nullable<TemplateRef<any>>;
+    private selectionSource;
+    _selection: any;
+    initialized: Nullable<boolean>;
+    selectionSource$: rxjs.Observable<any>;
+    _componentStyle: OrganizationChartStyle;
+    constructor(el: ElementRef, cd: ChangeDetectorRef);
+    get root(): TreeNode<any> | null;
+    ngAfterContentInit(): void;
+    getTemplateForNode(node: TreeNode): TemplateRef<any> | null;
+    onNodeClick(event: Event, node: TreeNode): void;
+    findIndexInSelection(node: TreeNode): number;
+    isSelected(node: TreeNode): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationChart, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OrganizationChart, "p-organizationChart, p-organization-chart, p-organizationchart", never, { "value": { "alias": "value"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "preserveSpace": { "alias": "preserveSpace"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; }, { "selectionChange": "selectionChange"; "onNodeSelect": "onNodeSelect"; "onNodeUnselect": "onNodeUnselect"; "onNodeExpand": "onNodeExpand"; "onNodeCollapse": "onNodeCollapse"; }, ["togglerIconTemplate", "templates"], never, true, never>;
+    static ngAcceptInputType_collapsible: unknown;
+    static ngAcceptInputType_preserveSpace: unknown;
+}
+declare class OrganizationChartModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganizationChartModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OrganizationChartModule, never, [typeof OrganizationChart, typeof OrganizationChartNode, typeof i1.SharedModule], [typeof OrganizationChart, typeof OrganizationChartNode, typeof i1.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OrganizationChartModule>;
+}
+
+export { OrganizationChart, OrganizationChartClasses, OrganizationChartModule, OrganizationChartNode, OrganizationChartStyle };
+export type { OrganizationChartNodeCollapseEvent, OrganizationChartNodeExpandEvent, OrganizationChartNodeSelectEvent, OrganizationChartNodeUnSelectEvent, OrganizationChartTemplates };

package/overlay/index.d.ts

@@ -0,0 +1,255 @@
+import * as i1 from 'primeng/api';
+import { OverlayService, OverlayModeType, ResponsiveOverlayOptions, OverlayOptions, OverlayOnBeforeShowEvent, OverlayOnShowEvent, OverlayOnBeforeHideEvent, OverlayOnHideEvent } from 'primeng/api';
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnDestroy, EventEmitter, ElementRef, TemplateRef, QueryList, NgZone } from '@angular/core';
+import { AnimationEvent } from '@angular/animations';
+import { BaseComponent } from 'primeng/basecomponent';
+import { BaseStyle } from 'primeng/base';
+
+declare class OverlayStyle extends BaseStyle {
+    name: string;
+    theme: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayStyle>;
+}
+
+/**
+ * This API allows overlay components to be controlled from the PrimeNG. In this way, all overlay components in the application can have the same behavior.
+ * @group Components
+ */
+declare class Overlay extends BaseComponent implements AfterContentInit, OnDestroy {
+    overlayService: OverlayService;
+    private zone;
+    /**
+     * The visible property is an input that determines the visibility of the component.
+     * @defaultValue false
+     * @group Props
+     */
+    get visible(): boolean;
+    set visible(value: boolean);
+    /**
+     * The mode property is an input that determines the overlay mode type or string.
+     * @defaultValue null
+     * @group Props
+     */
+    get mode(): OverlayModeType | string;
+    set mode(value: OverlayModeType | string);
+    /**
+     * The style property is an input that determines the style object for the component.
+     * @defaultValue null
+     * @group Props
+     */
+    get style(): {
+        [klass: string]: any;
+    } | null | undefined;
+    set style(value: {
+        [klass: string]: any;
+    } | null | undefined);
+    /**
+     * The styleClass property is an input that determines the CSS class(es) for the component.
+     * @defaultValue null
+     * @group Props
+     */
+    get styleClass(): string;
+    set styleClass(value: string);
+    /**
+     * The contentStyle property is an input that determines the style object for the content of the component.
+     * @defaultValue null
+     * @group Props
+     */
+    get contentStyle(): {
+        [klass: string]: any;
+    } | null | undefined;
+    set contentStyle(value: {
+        [klass: string]: any;
+    } | null | undefined);
+    /**
+     * The contentStyleClass property is an input that determines the CSS class(es) for the content of the component.
+     * @defaultValue null
+     * @group Props
+     */
+    get contentStyleClass(): string;
+    set contentStyleClass(value: string);
+    /**
+     * The target property is an input that specifies the target element or selector for the component.
+     * @defaultValue null
+     * @group Props
+     */
+    get target(): string | null | undefined;
+    set target(value: string | null | undefined);
+    /**
+     * The autoZIndex determines whether to automatically manage layering. Its default value is 'false'.
+     * @defaultValue false
+     * @group Props
+     */
+    get autoZIndex(): boolean;
+    set autoZIndex(value: boolean);
+    /**
+     * The baseZIndex is base zIndex value to use in layering.
+     * @defaultValue null
+     * @group Props
+     */
+    get baseZIndex(): number;
+    set baseZIndex(value: number);
+    /**
+     * Transition options of the show or hide animation.
+     * @defaultValue .12s cubic-bezier(0, 0, 0.2, 1)
+     * @group Props
+     */
+    get showTransitionOptions(): string;
+    set showTransitionOptions(value: string);
+    /**
+     * The hideTransitionOptions property is an input that determines the CSS transition options for hiding the component.
+     * @defaultValue .1s linear
+     * @group Props
+     */
+    get hideTransitionOptions(): string;
+    set hideTransitionOptions(value: string);
+    /**
+     * The listener property is an input that specifies the listener object for the component.
+     * @defaultValue null
+     * @group Props
+     */
+    get listener(): any;
+    set listener(value: any);
+    /**
+     * It is the option used to determine in which mode it should appear according to the given media or breakpoint.
+     * @defaultValue null
+     * @group Props
+     */
+    get responsive(): ResponsiveOverlayOptions | undefined;
+    set responsive(val: ResponsiveOverlayOptions | undefined);
+    /**
+     * The options property is an input that specifies the overlay options for the component.
+     * @defaultValue null
+     * @group Props
+     */
+    get options(): OverlayOptions | undefined;
+    set options(val: OverlayOptions | undefined);
+    /**
+     * Target element to attach the overlay, valid values are "body" or a local ng-template variable of another element (note: use binding with brackets for template variables, e.g. [appendTo]="mydiv" for a div element having #mydiv as variable name).
+     * @defaultValue 'self'
+     * @group Props
+     */
+    appendTo: i0.InputSignal<any>;
+    /**
+     * This EventEmitter is used to notify changes in the visibility state of a component.
+     * @param {Boolean} boolean - Value of visibility as boolean.
+     * @group Emits
+     */
+    visibleChange: EventEmitter<boolean>;
+    /**
+     * Callback to invoke before the overlay is shown.
+     * @param {OverlayOnBeforeShowEvent} event - Custom overlay before show event.
+     * @group Emits
+     */
+    onBeforeShow: EventEmitter<OverlayOnBeforeShowEvent>;
+    /**
+     * Callback to invoke when the overlay is shown.
+     * @param {OverlayOnShowEvent} event - Custom overlay show event.
+     * @group Emits
+     */
+    onShow: EventEmitter<OverlayOnShowEvent>;
+    /**
+     * Callback to invoke before the overlay is hidden.
+     * @param {OverlayOnBeforeHideEvent} event - Custom overlay before hide event.
+     * @group Emits
+     */
+    onBeforeHide: EventEmitter<OverlayOnBeforeHideEvent>;
+    /**
+     * Callback to invoke when the overlay is hidden
+     * @param {OverlayOnHideEvent} event - Custom hide event.
+     * @group Emits
+     */
+    onHide: EventEmitter<OverlayOnHideEvent>;
+    /**
+     * Callback to invoke when the animation is started.
+     * @param {AnimationEvent} event - Animation event.
+     * @group Emits
+     */
+    onAnimationStart: EventEmitter<AnimationEvent>;
+    /**
+     * Callback to invoke when the animation is done.
+     * @param {AnimationEvent} event - Animation event.
+     * @group Emits
+     */
+    onAnimationDone: EventEmitter<AnimationEvent>;
+    overlayViewChild: ElementRef | undefined;
+    contentViewChild: ElementRef | undefined;
+    /**
+     * Content template of the component.
+     * @group Templates
+     */
+    contentTemplate: TemplateRef<any> | undefined;
+    templates: QueryList<any> | undefined;
+    hostAttrSelector: i0.InputSignal<string>;
+    $appendTo: i0.Signal<any>;
+    _contentTemplate: TemplateRef<any> | undefined;
+    _visible: boolean;
+    _mode: OverlayModeType | string;
+    _style: {
+        [klass: string]: any;
+    } | null | undefined;
+    _styleClass: string | undefined;
+    _contentStyle: {
+        [klass: string]: any;
+    } | null | undefined;
+    _contentStyleClass: string | undefined;
+    _target: any;
+    _autoZIndex: boolean | undefined;
+    _baseZIndex: number | undefined;
+    _showTransitionOptions: string | undefined;
+    _hideTransitionOptions: string | undefined;
+    _listener: any;
+    _responsive: ResponsiveOverlayOptions | undefined;
+    _options: OverlayOptions | undefined;
+    modalVisible: boolean;
+    isOverlayClicked: boolean;
+    isOverlayContentClicked: boolean;
+    scrollHandler: any;
+    documentClickListener: any;
+    documentResizeListener: any;
+    _componentStyle: OverlayStyle;
+    private documentKeyboardListener;
+    private window;
+    protected transformOptions: any;
+    get modal(): boolean;
+    get overlayMode(): string;
+    get overlayOptions(): OverlayOptions;
+    get overlayResponsiveOptions(): ResponsiveOverlayOptions;
+    get overlayResponsiveDirection(): i1.ResponsiveOverlayDirectionType;
+    get overlayEl(): any;
+    get contentEl(): any;
+    get targetEl(): any;
+    constructor(overlayService: OverlayService, zone: NgZone);
+    ngAfterContentInit(): void;
+    show(overlay?: HTMLElement, isFocus?: boolean): void;
+    hide(overlay?: HTMLElement, isFocus?: boolean): void;
+    alignOverlay(): void;
+    onVisibleChange(visible: boolean): void;
+    onOverlayClick(): void;
+    onOverlayContentClick(event: MouseEvent): void;
+    onOverlayContentAnimationStart(event: AnimationEvent): void;
+    onOverlayContentAnimationDone(event: AnimationEvent): void;
+    handleEvents(name: string, params: any): void;
+    bindListeners(): void;
+    unbindListeners(): void;
+    bindScrollListener(): void;
+    unbindScrollListener(): void;
+    bindDocumentClickListener(): void;
+    unbindDocumentClickListener(): void;
+    bindDocumentResizeListener(): void;
+    unbindDocumentResizeListener(): void;
+    bindDocumentKeyboardListener(): void;
+    unbindDocumentKeyboardListener(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Overlay, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Overlay, "p-overlay", never, { "visible": { "alias": "visible"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "contentStyle": { "alias": "contentStyle"; "required": false; }; "contentStyleClass": { "alias": "contentStyleClass"; "required": false; }; "target": { "alias": "target"; "required": false; }; "autoZIndex": { "alias": "autoZIndex"; "required": false; }; "baseZIndex": { "alias": "baseZIndex"; "required": false; }; "showTransitionOptions": { "alias": "showTransitionOptions"; "required": false; }; "hideTransitionOptions": { "alias": "hideTransitionOptions"; "required": false; }; "listener": { "alias": "listener"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "options": { "alias": "options"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "hostAttrSelector": { "alias": "hostAttrSelector"; "required": false; "isSignal": true; }; }, { "visibleChange": "visibleChange"; "onBeforeShow": "onBeforeShow"; "onShow": "onShow"; "onBeforeHide": "onBeforeHide"; "onHide": "onHide"; "onAnimationStart": "onAnimationStart"; "onAnimationDone": "onAnimationDone"; }, ["contentTemplate", "templates"], ["*"], true, never>;
+}
+declare class OverlayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OverlayModule, never, [typeof Overlay, typeof i1.SharedModule], [typeof Overlay, typeof i1.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OverlayModule>;
+}
+
+export { Overlay, OverlayModule, OverlayStyle };

package/overlaybadge/index.d.ts

@@ -0,0 +1,73 @@
+import { BaseComponent } from 'primeng/basecomponent';
+import { BaseStyle } from 'primeng/base';
+import * as i0 from '@angular/core';
+import * as i1 from 'primeng/api';
+
+declare class OverlayBadgeStyle extends BaseStyle {
+    name: string;
+    theme: string;
+    classes: {
+        root: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayBadgeStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayBadgeStyle>;
+}
+
+/**
+ * OverlayPanel is a container component positioned as connected to its target.
+ * @group Components
+ */
+declare class OverlayBadge extends BaseComponent {
+    /**
+     * Class of the element.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Inline style of the element.
+     * @group Props
+     */
+    style: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     */
+    badgeSize: 'small' | 'large' | 'xlarge' | null | undefined;
+    /**
+     * Severity type of the badge.
+     * @group Props
+     */
+    severity: 'secondary' | 'info' | 'success' | 'warn' | 'danger' | 'contrast' | null | undefined;
+    /**
+     * Value to display inside the badge.
+     * @group Props
+     */
+    value: string | number | null | undefined;
+    /**
+     * When specified, disables the component.
+     * @group Props
+     */
+    badgeDisabled: boolean;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     * @deprecated use badgeSize instead.
+     */
+    set size(value: 'large' | 'xlarge' | 'small' | undefined | null);
+    get size(): "large" | "xlarge" | "small" | undefined | null;
+    _size: 'large' | 'xlarge' | 'small' | undefined | null;
+    _componentStyle: OverlayBadgeStyle;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayBadge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OverlayBadge, "p-overlayBadge, p-overlay-badge, p-overlaybadge", never, { "styleClass": { "alias": "styleClass"; "required": false; }; "style": { "alias": "style"; "required": false; }; "badgeSize": { "alias": "badgeSize"; "required": false; }; "severity": { "alias": "severity"; "required": false; }; "value": { "alias": "value"; "required": false; }; "badgeDisabled": { "alias": "badgeDisabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_badgeDisabled: unknown;
+}
+declare class OverlayBadgeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayBadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OverlayBadgeModule, never, [typeof OverlayBadge, typeof i1.SharedModule], [typeof OverlayBadge, typeof i1.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OverlayBadgeModule>;
+}
+
+export { OverlayBadge, OverlayBadgeModule, OverlayBadgeStyle };