@unipin/angular-applet 18.9.7 → 21.0.1

package/types/unipin-angular-applet-collapsible.d.ts

@@ -0,0 +1,35 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { ClassValue } from 'clsx';
+
+declare class UpCollapsibleDirective {
+    readonly isOpened: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    setOpen(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpCollapsibleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpCollapsibleDirective, "[upCollapsible]", ["upCollapsible"], { "isOpened": { "alias": "isOpened"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "isOpened": "isOpenedChange"; }, never, never, true, never>;
+}
+
+declare class UpCollapsibleTriggerDirective {
+    protected readonly parent: UpCollapsibleDirective;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    constructor(parent: UpCollapsibleDirective);
+    toggleState(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpCollapsibleTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpCollapsibleTriggerDirective, "[upCollapsibleTrigger]", ["upCollapsibleTrigger"], { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpCollapsibleContentDirective {
+    protected readonly elementRef: ElementRef;
+    protected readonly parent: UpCollapsibleDirective;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _contentHeight: _angular_core.Signal<string>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    constructor(elementRef: ElementRef, parent: UpCollapsibleDirective);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpCollapsibleContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpCollapsibleContentDirective, "[upCollapsibleContent]", ["upCollapsibleContent"], { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { UpCollapsibleContentDirective, UpCollapsibleDirective, UpCollapsibleTriggerDirective };

package/types/unipin-angular-applet-common.d.ts

@@ -0,0 +1,94 @@
+import { ClassValue } from 'clsx';
+import * as i0 from '@angular/core';
+import { PipeTransform, OnInit, ElementRef } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { GqlParser, QueryResult } from '@unipin/angular-gql';
+import { CountryQueryCriteria, CountryResult, CurrencyQueryCriteria, CurrencyResult } from '@unipin/graphql-schema';
+
+declare function up(...inputs: ClassValue[]): string;
+
+type ImageCompressionOptions = {
+    file: File;
+    quality?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+};
+declare function compressImage({ file, quality, maxWidth, maxHeight }: ImageCompressionOptions): Promise<File>;
+
+declare function generateContrastColor(str: string): {
+    background: string;
+    foreground: string;
+};
+
+declare class UpPricePipe implements PipeTransform {
+    transform(value: string, magnifyValue?: string | number, format?: 'string' | 'number'): string | number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpPricePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UpPricePipe, "upPrice", true>;
+}
+declare function formatPrice(value: number, magnifyValue?: number, format?: 'string' | 'number'): string | number;
+
+declare class UpInitialPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpInitialPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UpInitialPipe, "upInitial", true>;
+}
+declare function formatInitial(value: string): string;
+
+declare class UpLinkifyPipe {
+    protected readonly sanitizer: DomSanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: any): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpLinkifyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UpLinkifyPipe, "upLinkify", true>;
+}
+declare function formatLinkify(value: string, sanitizer: DomSanitizer): SafeHtml;
+
+declare class UpCapitalizaPipe {
+    transform(value: string | string[], onlyFirstWord?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpCapitalizaPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UpCapitalizaPipe, "upCapitalize", true>;
+}
+/**
+ * A function that create a capitalize word.
+ * @param {string | string[]} str - Word that want to be capitalized.
+ * @param {boolean} [onlyFirstWord=true] - Determine whether only the first word will be capitalize or not. If the first param is not array, this parameter will be ignored. Default to `true`.
+ * @returns {string} Capitalized word string
+ */
+declare function formatCapitalize(str: string | string[], onlyFirstWord?: boolean): string;
+
+declare class CountryService {
+    protected readonly gql: GqlParser;
+    constructor(gql: GqlParser);
+    query(input?: CountryQueryCriteria): Observable<QueryResult<{
+        webConfigMsCountry: CountryResult;
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CountryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CountryService>;
+}
+
+declare class CurrencyService {
+    protected readonly gql: GqlParser;
+    constructor(gql: GqlParser);
+    query(input?: CurrencyQueryCriteria): Observable<QueryResult<{
+        webConfigMsCurrency: CurrencyResult;
+    }>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CurrencyService>;
+}
+
+declare class UpFileDragNDropDirective implements OnInit {
+    protected readonly el: ElementRef;
+    readonly draggedClass: i0.InputSignal<ClassValue>;
+    readonly fileDropped: i0.OutputEmitterRef<File>;
+    protected currentClass: ClassValue;
+    constructor(el: ElementRef);
+    ngOnInit(): void;
+    dragOver(evt: any): void;
+    leave(evt: any): void;
+    drop(evt: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpFileDragNDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UpFileDragNDropDirective, "[upFileDragNDrop]", ["upFileDragNDrop"], { "draggedClass": { "alias": "draggedClass"; "required": false; "isSignal": true; }; }, { "fileDropped": "fileDropped"; }, never, never, true, never>;
+}
+
+export { CountryService, CurrencyService, UpCapitalizaPipe, UpFileDragNDropDirective, UpInitialPipe, UpLinkifyPipe, UpPricePipe, compressImage, formatCapitalize, formatInitial, formatLinkify, formatPrice, generateContrastColor, up };

package/types/unipin-angular-applet-containers.d.ts

@@ -0,0 +1,179 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, ViewContainerRef, DestroyRef, ComponentRef, ComponentMirror, Provider, InjectionToken } from '@angular/core';
+import { Router, ActivatedRoute, Route, RedirectFunction } from '@angular/router';
+import { PermissionService } from '@unipin/angular-applet/auth';
+
+declare class UpLazyRouteDirective implements OnInit {
+    protected readonly router: Router;
+    protected readonly vcr: ViewContainerRef;
+    protected readonly route: ActivatedRoute;
+    protected readonly destroyRef: DestroyRef;
+    /**
+     * Accepts a route config object containing `loadComponent`.
+     */
+    readonly loadRoute: _angular_core.InputSignal<Pick<Route, "loadComponent">>;
+    /**
+     * Lifecycle hook that is called after the directive's data-bound properties have been initialized.
+     * Dynamically loads the component using the `loadComponent` method and creates it within the directive's view container.
+     */
+    ngOnInit(): void;
+    /**
+     * Method to manually set Input to the child component, because component created by ViewContainerRef won't accept the input from route param directly.
+     * @param { ComponentRef<any> } cr
+     */
+    protected setInput(cr: ComponentRef<any>, mirror: ComponentMirror<unknown> | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpLazyRouteDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpLazyRouteDirective, "[upLoadRoute]", ["upLoadRoute"], { "loadRoute": { "alias": "loadRoute"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AppletConfig = {
+    icon: string;
+    name: string;
+    version: string;
+    enabledSetting?: boolean;
+    containers: {
+        icon: string;
+        label: string;
+        path: `/${string}`;
+        permissions?: {
+            codes: string[];
+            aggregator?: 'AND' | 'OR';
+        };
+    }[];
+};
+
+/**
+ * Redirects the user to their first accessible menu route based on permissions.
+ * @returns {RedirectFunction} The first allowed route
+ */
+declare function redirectToFirstMenu(): ReturnType<RedirectFunction>;
+
+declare const APPLET_CONFIG: InjectionToken<AppletConfig>;
+declare function provideAppletConfig(config: AppletConfig): Provider;
+
+declare class AppletContainerComponent {
+    protected readonly permissionService: PermissionService;
+    readonly config: AppletConfig;
+    /**
+     * A flag variable that used to control sidebar. When set the the value to true, the component will open the sidebar.
+     * when set the value to false, the component will close the sidebar.
+     * @type {boolean}
+     */
+    readonly isExpanded: _angular_core.WritableSignal<boolean>;
+    /**
+     * A flag variable for indicates whether the sidebar menu is active or not in mobile view.
+     * When set false the sidebar menu will be hidden
+     * @type {boolean[]}
+     */
+    readonly isMenuActive: _angular_core.WritableSignal<boolean>;
+    /**
+     * A flag variable that used to control sidebar menu. When set value to true, the component will hide the sidebar menu.
+     * When set false, the component will show the sidebar menu.
+     * @type {boolean[]}
+     */
+    readonly isHidden: _angular_core.WritableSignal<boolean[]>;
+    constructor(permissionService: PermissionService);
+    /**
+     * When the method is called, it will change the value of isExpanded to its opposite value.
+     * If isExpanded is currently true, it will be set to false, and if it is currently false, it will be set to true.
+     * This method is typically used to toggle the visibility of a side navigation menu.
+     */
+    toggleSidenav(): void;
+    /**
+     * Handles menu selection by dispatching a custom event.
+     * This method is called when a sidebar menu item is selected.
+     * It dispatches a custom 'menuEvent' with detail indicating the menu is inactive.
+     * This event is typically used to close the sidebar menu.
+     */
+    selectMenu(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppletContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppletContainerComponent, "up-applet-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class UpColumnContainerComponent implements OnInit {
+    protected readonly router: Router;
+    protected readonly destroyRef: DestroyRef;
+    protected readonly activeRoute: ActivatedRoute;
+    /**
+     * An array of objects representing the columns, each containing a visibility flag and the associated route.
+     * @type {{ visible: boolean, route: Route }[]}
+     * @default {[]}
+     */
+    readonly areas: _angular_core.WritableSignal<{
+        visible: boolean;
+        route: Pick<Route, "loadComponent">;
+    }[]>;
+    /**
+     * The default size for the split area: 100 means it will be full width, and 50 means it will be divided in half.
+     * This can be resizable with minimum width 20%
+     */
+    readonly colSize: _angular_core.WritableSignal<number>;
+    /**
+   * An object to keep track of the position of opened areas based on their route paths.
+   * @type {{ [key: string]: number }}
+   * @default {{}}
+   */
+    protected readonly openedArea: Record<string, number>;
+    constructor(router: Router, destroyRef: DestroyRef, activeRoute: ActivatedRoute);
+    /**
+     * Lifecycle hook called after the component has been initialized.
+     * Subscribes to router events, initializes columns based on the initial route, and sets up the first visible column.
+     */
+    ngOnInit(): void;
+    /**
+     * Event listener for the window resize event. Adjusts the default size of the split area based on the screen width.
+     */
+    checkScreen(): void;
+    /**
+     * Handles router navigation events and adjusts the display of columns accordingly.
+     */
+    protected navigate(): void;
+    /**
+     * Adds a new column to the container and updates visibility based on the route navigation.
+     * @param {Route} route - Contain next route.
+     */
+    protected next(route: Route): void;
+    /**
+     * Removes columns from the container based on the route navigation.
+     * @param {number} pos - Contain position of the last active area index.
+     */
+    protected previous(pos: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpColumnContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UpColumnContainerComponent, "up-column-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class UpContentContainerComponent {
+    /**
+     * The title text displayed in the header.
+     * If the text is too long, it will be truncated with an ellipsis.
+     * @type {Signal<string>}
+     * @default ''
+     */
+    readonly header: _angular_core.InputSignal<string>;
+    /**
+     * Disables the close/back button when set to true.
+     * When disabled, the close button will not be shown in the header.
+     * @type {Signal<boolean>}
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Hides the close/back button when set to true.
+     * When hidden, the close button will not be shown in the header.
+     * @type {Signal<boolean>}
+     * @default false
+     */
+    readonly hideCloseButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Event emitted when the user clicks the close button.
+     * Typically used to handle closing a modal or navigating back.
+     * @type {OutputEmitterRef<void>}
+     */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly _headerClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpContentContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UpContentContainerComponent, "up-content-container", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hideCloseButton": { "alias": "hideCloseButton"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["[actions]", "*"], true, never>;
+}
+
+export { APPLET_CONFIG, AppletContainerComponent, UpColumnContainerComponent, UpContentContainerComponent, UpLazyRouteDirective, provideAppletConfig, redirectToFirstMenu };
+export type { AppletConfig };

package/types/unipin-angular-applet-dialog.d.ts

@@ -0,0 +1,180 @@
+import * as _angular_core from '@angular/core';
+import { StaticProvider, ElementRef, InjectOptions, ValueProvider, Signal, WritableSignal, Injector, RendererFactory2, TemplateRef, ViewContainerRef, EffectRef, OnDestroy, OutputRefSubscription } from '@angular/core';
+import * as _angular_cdk_dialog from '@angular/cdk/dialog';
+import { AutoFocusTarget, DialogRef, Dialog } from '@angular/cdk/dialog';
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { PositionStrategy, ScrollStrategy, ConnectedPosition, FlexibleConnectedPositionStrategyOrigin, OverlayPositionBuilder, ScrollStrategyOptions, ComponentType } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+import { ClassValue } from 'clsx';
+
+type UpDialogOptions = {
+    id?: string;
+    hasBackdrop: boolean;
+    disableClose: boolean;
+    role: 'dialog' | 'alertdialog';
+    providers?: StaticProvider[] | (() => StaticProvider[]);
+    restoreFocus: boolean | string | ElementRef;
+    autoFocus?: AutoFocusTarget | (Record<never, never> & string);
+    closeDelay: number;
+    closeOnBackdropClick: boolean;
+    closeOnOutsidePointerEvents: boolean;
+    positionStrategy?: PositionStrategy | null;
+    scrollStrategy: ScrollStrategy | 'close' | 'reposition' | null;
+    attachPositions: ConnectedPosition[];
+    attachTo?: FlexibleConnectedPositionStrategyOrigin | null;
+};
+
+declare const defaultDialogOptions: UpDialogOptions;
+
+declare const injectDialogContext: <DialogContext = any>(options?: InjectOptions) => DialogContext;
+
+declare function provideDialogDefaultOptions(options: Partial<UpDialogOptions>): ValueProvider;
+declare function injectDialogDefaultOptions(): UpDialogOptions;
+
+type ExposesState = {
+    state: Signal<'open' | 'closed'>;
+};
+declare const injectExposesStateProvider: {
+    (): ExposesState;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional?: false;
+    }): ExposesState;
+    (injectOptions: _angular_core.InjectOptions & {
+        optional: true;
+    }): ExposesState | null;
+};
+declare const provideExposesStateProvider: (value: ExposesState) => _angular_core.Provider;
+declare const provideExposesStateProviderExisting: (valueFactory: () => _angular_core.Type<ExposesState>) => _angular_core.Provider;
+declare const EXPOSES_STATE_TOKEN: _angular_core.InjectionToken<ExposesState>;
+
+declare class UpDialogRef<DialogResult = any> {
+    readonly state: Signal<'closed' | 'open'>;
+    protected readonly open: WritableSignal<boolean>;
+    protected readonly cdkDialogRef: DialogRef<DialogResult>;
+    protected readonly options?: UpDialogOptions | undefined;
+    readonly closed$: Observable<DialogResult | undefined>;
+    readonly isOpen: Signal<boolean>;
+    previousTimeout: ReturnType<typeof setTimeout> | undefined;
+    constructor(state: Signal<'closed' | 'open'>, open: WritableSignal<boolean>, cdkDialogRef: DialogRef<DialogResult>, options?: UpDialogOptions | undefined);
+    close(result?: DialogResult, delay?: number): void;
+}
+
+type DialogOpenOptions<T> = {
+    content: ComponentType<unknown> | TemplateRef<unknown>;
+    context?: T;
+    vcr?: ViewContainerRef;
+    options?: Partial<UpDialogOptions>;
+};
+declare class UpDialogService {
+    readonly cdkDialog: Dialog;
+    readonly injector: Injector;
+    readonly rendererFactory: RendererFactory2;
+    readonly positionBuilder: OverlayPositionBuilder;
+    readonly scrollStrategyOptions: ScrollStrategyOptions;
+    readonly renderer: _angular_core.Renderer2;
+    open<DialogContext>({ content, vcr, context, options }: DialogOpenOptions<DialogContext>): UpDialogRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UpDialogService>;
+}
+
+declare class UpDialog {
+    readonly injector: Injector;
+    readonly dialogService: UpDialogService;
+    readonly viewContainerRef: ViewContainerRef;
+    readonly positionBuilder: OverlayPositionBuilder;
+    readonly scrollStrategyOptions: ScrollStrategyOptions;
+    readonly defaultOptions: UpDialogOptions;
+    readonly attachTo: _angular_core.InputSignal<_angular_cdk_overlay.FlexibleConnectedPositionStrategyOrigin | null | undefined>;
+    readonly role: _angular_core.InputSignal<"dialog" | "alertdialog">;
+    readonly autoFocus: _angular_core.InputSignal<_angular_cdk_dialog.AutoFocusTarget | (Record<never, never> & string) | undefined>;
+    readonly restoreFocus: _angular_core.InputSignal<string | boolean | _angular_core.ElementRef<any>>;
+    readonly scrollStrategy: _angular_core.InputSignal<ScrollStrategy | "close" | "reposition" | null>;
+    readonly attachPositions: _angular_core.InputSignal<_angular_cdk_overlay.ConnectedPosition[]>;
+    readonly positionStrategy: _angular_core.InputSignal<_angular_cdk_overlay.PositionStrategy | null | undefined>;
+    readonly hasBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disableClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly closeOnOutsidePointerEvents: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closeOnBackdropClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closed: _angular_core.OutputEmitterRef<any>;
+    readonly stateChanged: _angular_core.OutputEmitterRef<"open" | "closed">;
+    readonly state: WritableSignal<boolean>;
+    readonly mutableAttachTo: _angular_core.Signal<WritableSignal<_angular_cdk_overlay.FlexibleConnectedPositionStrategyOrigin | null | undefined>>;
+    readonly stateComputed: _angular_core.Signal<"open" | "closed">;
+    readonly mutableAttachPositions: _angular_core.Signal<WritableSignal<_angular_cdk_overlay.ConnectedPosition[]>>;
+    readonly mutablePositionStrategy: _angular_core.Signal<WritableSignal<_angular_cdk_overlay.PositionStrategy | null | undefined>>;
+    readonly mutableCloseOnOutsidePointerEvents: _angular_core.Signal<WritableSignal<boolean>>;
+    dialogRef: UpDialogRef | undefined;
+    protected readonly attachToState: _angular_core.Signal<_angular_cdk_overlay.FlexibleConnectedPositionStrategyOrigin | null | undefined>;
+    protected readonly positionStrategyState: _angular_core.Signal<_angular_cdk_overlay.PositionStrategy | null | undefined>;
+    protected readonly closeOnOutsidePointerEventsState: _angular_core.Signal<boolean>;
+    protected readonly attachPositionsState: _angular_core.Signal<_angular_cdk_overlay.ConnectedPosition[]>;
+    protected readonly options: _angular_core.Signal<Partial<UpDialogOptions>>;
+    protected context: {};
+    protected dialogStateEffectRef?: EffectRef;
+    protected contentTemplate: TemplateRef<unknown> | undefined;
+    constructor();
+    close(result?: any, delay?: number): void;
+    registerTemplate(template: TemplateRef<unknown>): void;
+    setContext<T extends object>(context: T): void;
+    open<DialogContext>(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UpDialog, "up-dialog", ["upDialog"], { "attachTo": { "alias": "attachTo"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; "isSignal": true; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; "isSignal": true; }; "attachPositions": { "alias": "attachPositions"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "disableClose": { "alias": "disableClose"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "closeOnOutsidePointerEvents": { "alias": "closeOnOutsidePointerEvents"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "stateChanged": "stateChanged"; }, never, ["*"], true, never>;
+}
+
+declare class UpDialogCloseDirective {
+    readonly dialogRef: UpDialogRef<any>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpDialogCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpDialogCloseDirective, "button[upDialogClose]", never, { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpDialogContentDirective {
+    readonly dialogRef: UpDialogRef<any>;
+    readonly inlineClass: _angular_core.InputSignal<ClassValue>;
+    readonly state: _angular_core.Signal<"open" | "closed">;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpDialogContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpDialogContentDirective, "[upDialogContent]", ["upDialogContent"], { "inlineClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpDialogTriggerDirective {
+    readonly dialogRef: UpDialogRef<any> | null;
+    dialog: UpDialog | null;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly dialogTriggerFor: _angular_core.InputSignal<UpDialog | undefined>;
+    readonly mutableDialogTriggerFor: _angular_core.Signal<_angular_core.WritableSignal<UpDialog | undefined>>;
+    readonly dialogTriggerForState: _angular_core.Signal<UpDialog | undefined>;
+    readonly state: _angular_core.Signal<"open" | "closed">;
+    constructor();
+    open(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpDialogTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpDialogTriggerDirective, "button[upDialogTrigger], button[upDialogTriggerFor]", ["upDialogTrigger"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dialogTriggerFor": { "alias": "upDialogTriggerFor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpDialogContentRefDirective<T> {
+    readonly template: TemplateRef<any>;
+    readonly dialog: UpDialog | null;
+    readonly dialogRef: UpDialogRef<any> | null;
+    readonly dialogContext: any;
+    readonly context: _angular_core.InputSignal<T | undefined>;
+    readonly state: _angular_core.Signal<"open" | "closed">;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpDialogContentRefDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UpDialogContentRefDirective<any>, "[upDialogContentRef]", ["upDialogContentRef"], { "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UpDialogWrapperComponent extends UpDialog implements OnDestroy {
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    protected readonly closedSubscription: OutputRefSubscription;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UpDialogWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UpDialogWrapperComponent, "up-dialog-wrapper", ["upDialogWrapper"], { "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+export { EXPOSES_STATE_TOKEN, UpDialog, UpDialogCloseDirective, UpDialogContentDirective, UpDialogContentRefDirective, UpDialogRef, UpDialogService, UpDialogTriggerDirective, UpDialogWrapperComponent, defaultDialogOptions, injectDialogContext, injectDialogDefaultOptions, injectExposesStateProvider, provideDialogDefaultOptions, provideExposesStateProvider, provideExposesStateProviderExisting };
+export type { ExposesState, UpDialogOptions };