@3ddv/software-division-components 1.5.0 → 2.0.0

package/dist/types/3ddv-software-division-components-generic-button.d.ts

@@ -0,0 +1,186 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, ValueProvider } from '@angular/core';
+import { Size } from '@3ddv/software-division-components/shared';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+declare const BUTTON_VARIANTS: {
+    readonly primary: "primary";
+    readonly secondary: "secondary";
+    readonly accent: "accent";
+    readonly alternative: "alternative";
+    readonly warning: "warning";
+    readonly success: "success";
+    readonly outline: "outline";
+    readonly destructive: "destructive";
+    readonly 'primary-light': "primary-light";
+    readonly 'alternative-light': "alternative-light";
+    readonly 'success-muted': "success-muted";
+    readonly 'accent-light': "accent-light";
+    readonly 'warning-light': "warning-light";
+    readonly 'destructive-light': "destructive-light";
+    readonly 'outline-white': "outline-white";
+    readonly 'outline-alternative': "outline-alternative";
+    readonly 'outline-accent': "outline-accent";
+    readonly link: "link";
+};
+type ButtonVariant = (typeof BUTTON_VARIANTS)[keyof typeof BUTTON_VARIANTS];
+type ButtonType = 'button' | 'submit' | 'reset';
+type ButtonStyleClasses = ReturnType<(typeof ButtonComponent.prototype)['styleClass']>;
+/**
+ * A customizable button component built on Spartan UI Button.
+ *
+ * This component supports various configurations and exposes all Spartan UI button functionality.
+ * All HTML button attributes and events are automatically forwarded to the inner button element.
+ *
+ * @since 1.0.0-alpha.1
+ * @updated 1.0.0-alpha.3
+ */
+declare class ButtonComponent {
+    private elementRef;
+    private readonly allowedVariants;
+    private readonly allowedSizes;
+    private readonly allowedCircleSizes;
+    private readonly allowedRadius;
+    private readonly allowedBorder;
+    /**
+     * The current theme applied to the component.
+     */
+    readonly theme: _angular_core.InputSignal<"theme-backoffice" | "theme-sdc">;
+    /**
+     * Predefined styles to apply to the component.
+     * Can be a single class or multiple classes from different categories.
+     */
+    readonly styleClass: _angular_core.InputSignal<("variant-destructive" | "variant-outline" | "variant-secondary" | "variant-link" | "variant-primary" | "variant-accent" | "variant-alternative" | "variant-warning" | "variant-success" | "variant-primary-light" | "variant-alternative-light" | "variant-success-muted" | "variant-accent-light" | "variant-warning-light" | "variant-destructive-light" | "variant-outline-white" | "variant-outline-alternative" | "variant-outline-accent" | "size-sm" | "size-lg" | "size-xxs" | "size-xs" | "size-md" | "size-xl" | "size-2xl" | "size-circle-sm" | "size-circle-md" | "size-circle-lg" | "size-circle-xl" | "radius-default" | "radius-sm" | "radius-md" | "radius-lg" | "radius-xl" | "radius-2xl" | "radius-full" | "border-0" | "border-default" | "border-2" | "border-4" | "border-8")[]>;
+    private readonly _validatedStyleClass;
+    /**
+     * Additional classes
+     */
+    readonly className: _angular_core.InputSignal<string>;
+    /**
+     * Button component style variant
+     */
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
+    /**
+     * Button component size variant
+     */
+    readonly size: _angular_core.InputSignal<Size>;
+    /**
+     * Native button type attribute
+     */
+    readonly type: _angular_core.InputSignal<ButtonType>;
+    /**
+     * Whether the component is disabled.
+     */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to enable the ripple effect on the component.
+     * Default value is false.
+     */
+    readonly ripple: _angular_core.InputSignal<boolean>;
+    /**
+     * Event emitted when the component is clicked.
+     */
+    readonly onClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    /**
+     * Event emitted when the component receives focus.
+     */
+    readonly onFocus: _angular_core.OutputEmitterRef<FocusEvent>;
+    /**
+     * Event emitted when the component loses focus.
+     */
+    readonly onBlur: _angular_core.OutputEmitterRef<FocusEvent>;
+    protected readonly _sizeClass: _angular_core.Signal<string>;
+    protected readonly _variantClass: _angular_core.Signal<string>;
+    /**
+     * Computed class string that combines theme and user classes.
+     */
+    protected readonly computedClass: _angular_core.Signal<string>;
+    /**
+     * Debounce time in milliseconds. When null, no debounce is applied.
+     * Default value is null (no debounce).
+     */
+    readonly debounce: _angular_core.InputSignal<number | null>;
+    /**
+     * Event emitted to notify the debounce state.
+     * Returns true while the component is debounced, false when not.
+     */
+    readonly isDebounced: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Signal to track the current debounce state of the component.
+     */
+    protected readonly debounceState: _angular_core.WritableSignal<boolean>;
+    /**
+     * Subject for handling click events with debounce.
+     */
+    private readonly clickSubject;
+    /**
+     * Subject for cleanup.
+     */
+    private readonly destroy$;
+    /**
+     * Current subscription for debounce.
+     */
+    private debounceSubscription;
+    /**
+     * Current debounce timeout.
+     */
+    private debounceTimeout;
+    constructor(elementRef: ElementRef);
+    ngOnDestroy(): void;
+    /**
+     * Sets up the debounce functionality for click events.
+     */
+    private setupDebounce;
+    /**
+     * Handles click events with debounce functionality.
+     */
+    protected handleClick(event: MouseEvent): void;
+    /**
+     * Handles focus events and emits the onFocus output.
+     */
+    protected handleFocus(event: FocusEvent): void;
+    /**
+     * Handles blur events and emits the onBlur output.
+     */
+    protected handleBlur(event: FocusEvent): void;
+    /**
+     * Creates a ripple effect at the specified position.
+     */
+    protected createRipple(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "sdc-button", never, { "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ripple": { "alias": "ripple"; "required": false; "isSignal": true; }; "debounce": { "alias": "debounce"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; "onFocus": "onFocus"; "onBlur": "onBlur"; "isDebounced": "isDebounced"; }, never, ["*"], true, never>;
+}
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariants = VariantProps<typeof buttonVariants>;
+declare class HlmButton {
+    private readonly _config;
+    private readonly _additionalClasses;
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    readonly variant: _angular_core.InputSignal<"default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "sm" | "lg" | "icon" | null | undefined>;
+    setClass(classes: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmButton, "[hlmBtn]", ["hlmBtn"], { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface BrnButtonConfig {
+    variant: ButtonVariants['variant'];
+    size: ButtonVariants['size'];
+}
+declare function provideBrnButtonConfig(config: Partial<BrnButtonConfig>): ValueProvider;
+
+declare class HlmButtonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmButtonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<HlmButtonModule, never, [typeof HlmButton], [typeof HlmButton]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<HlmButtonModule>;
+}
+
+export { ButtonComponent, HlmButton, HlmButtonModule, buttonVariants, provideBrnButtonConfig };
+export type { ButtonStyleClasses };

package/dist/types/3ddv-software-division-components-generic-dialog.d.ts

@@ -0,0 +1,104 @@
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as i1 from '@spartan-ng/brain/dialog';
+import { BrnDialog, BrnDialogRef, BrnDialogOptions } from '@spartan-ng/brain/dialog';
+import { ComponentType } from '@angular/cdk/portal';
+import { ClassValue } from 'clsx';
+
+declare class HlmDialog extends BrnDialog {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialog, "hlm-dialog", ["hlmDialog"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDialogClose {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogClose, "[hlmDialogClose],[brnDialogClose][hlm]", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmDialogContent {
+    private readonly _dialogRef;
+    private readonly _dialogContext;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    readonly state: i0.Signal<i1.BrnDialogState>;
+    readonly componentInputs: i0.Signal<any>;
+    protected readonly _computedClass: i0.Signal<string>;
+    readonly component: any;
+    private readonly _dynamicComponentClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialogContent, "hlm-dialog-content", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDialogDescription {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogDescription, "[hlmDialogDescription]", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnDialogDescription; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmDialogFooter {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialogFooter, "hlm-dialog-footer", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HlmDialogHeader {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HlmDialogHeader, "hlm-dialog-header", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const hlmDialogOverlayClass = "bg-black/50 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0";
+declare class HlmDialogOverlay {
+    private readonly _classSettable;
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogOverlay, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogOverlay, "[hlmDialogOverlay],brn-dialog-overlay[hlm]", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmDialogTitle {
+    readonly userClass: i0.InputSignal<ClassValue>;
+    protected readonly _computedClass: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HlmDialogTitle, "[hlmDialogTitle]", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnDialogTitle; inputs: {}; outputs: {}; }]>;
+}
+
+type HlmDialogOptions<DialogContext = unknown> = BrnDialogOptions & {
+    contentClass?: string;
+    context?: DialogContext;
+};
+declare class HlmDialogService {
+    ref: i0.WritableSignal<BrnDialogRef<any> | null>;
+    component: i0.WritableSignal<BrnDialog | null>;
+    private readonly _brnDialogService;
+    open(component: ComponentType<unknown> | TemplateRef<unknown>, options?: Partial<HlmDialogOptions>): {
+        reference: BrnDialogRef<any>;
+        component: ComponentType<unknown> | TemplateRef<unknown>;
+    };
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HlmDialogService>;
+}
+
+declare const HlmDialogImports: readonly [typeof HlmDialog, typeof HlmDialogClose, typeof HlmDialogContent, typeof HlmDialogDescription, typeof HlmDialogFooter, typeof HlmDialogHeader, typeof HlmDialogOverlay, typeof HlmDialogTitle];
+declare class HlmDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HlmDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HlmDialogModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HlmDialogModule>;
+}
+
+declare class DialogComponent {
+    dialogService: HlmDialogService;
+    dialogComponent: i0.Signal<BrnDialog | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "sdc-dialog", never, {}, {}, never, never, true, never>;
+}
+
+export { DialogComponent, HlmDialogService as DialogService, HlmDialog, HlmDialogClose, HlmDialogContent, HlmDialogDescription, HlmDialogFooter, HlmDialogHeader, HlmDialogImports, HlmDialogModule, HlmDialogOverlay, HlmDialogService, HlmDialogTitle, hlmDialogOverlayClass };
+export type { HlmDialogOptions };

package/dist/types/3ddv-software-division-components-generic-drawer.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from '@angular/core';
+
+declare class DrawerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerComponent, "sdc-drawer", never, {}, {}, never, never, true, never>;
+}
+
+declare class DrawerService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DrawerService>;
+}
+
+export { DrawerComponent, DrawerService };

package/dist/types/3ddv-software-division-components-generic-icon.d.ts

@@ -0,0 +1,38 @@
+import * as _angular_core from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+
+declare class SvgIconComponent {
+    private readonly http;
+    private readonly cache;
+    private readonly sanitizer;
+    private readonly elementRef;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly iconFolder: _angular_core.InputSignal<string | undefined>;
+    readonly className: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly strokeWidth: _angular_core.InputSignal<number>;
+    readonly svgContent: _angular_core.WritableSignal<SafeHtml | null>;
+    constructor();
+    getIcon(name: string): Observable<string>;
+    private sanitizeSvg;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvgIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SvgIconComponent, "sdc-svg-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "iconFolder": { "alias": "iconFolder"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type IconSize = 'xs' | 'sm' | 'base' | 'lg' | 'xl' | 'none' | (Record<never, never> & string);
+declare class HlmIcon {
+    private readonly _config;
+    readonly size: _angular_core.InputSignal<IconSize>;
+    protected readonly _computedSize: _angular_core.Signal<"none" | (Record<never, never> & string) | "12px" | "16px" | "24px" | "32px" | "48px">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmIcon, "ng-icon[hlm]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmIconModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmIconModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<HlmIconModule, never, [typeof HlmIcon], [typeof HlmIcon]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<HlmIconModule>;
+}
+
+export { HlmIcon, HlmIconModule, SvgIconComponent };

package/dist/types/3ddv-software-division-components-generic-select.d.ts

@@ -0,0 +1,110 @@
+import * as _angular_core from '@angular/core';
+import { ClassValue } from 'clsx';
+import * as _spartan_ng_brain_core from '@spartan-ng/brain/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1 from '@spartan-ng/brain/select';
+import { BrnSelectOption, BrnSelect } from '@spartan-ng/brain/select';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { HlmIcon } from '@3ddv/software-division-components/generic/icon';
+
+declare class HlmSelect {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelect, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmSelect, "hlm-select, brn-select [hlm]", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSelectContent {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    readonly stickyLabels: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly _stateProvider: _spartan_ng_brain_core.ExposesState | null;
+    protected readonly _sideProvider: _spartan_ng_brain_core.ExposesSide | null;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmSelectContent, "[hlmSelectContent], hlm-select-content", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "stickyLabels": { "alias": "stickyLabels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSelectGroup {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmSelectGroup, "[hlmSelectGroup], hlm-select-group", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnSelectGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectLabel {
+    private readonly _selectContent;
+    private readonly _stickyLabels;
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmSelectLabel, "[hlmSelectLabel], hlm-select-label", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.BrnSelectLabel; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HlmSelectOption {
+    protected readonly _brnSelectOption: BrnSelectOption<any>;
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectOption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmSelectOption, "hlm-option", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.BrnSelectOption; inputs: { "disabled": "disabled"; "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class HlmSelectScrollDown {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectScrollDown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmSelectScrollDown, "hlm-select-scroll-down", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HlmSelectScrollUp {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectScrollUp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmSelectScrollUp, "hlm-select-scroll-up", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const selectTriggerVariants: (props?: ({
+    error?: boolean | "auto" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare class HlmSelectTrigger {
+    protected readonly _icon: _angular_core.Signal<HlmIcon | undefined>;
+    protected readonly _brnSelect: BrnSelect<any> | null;
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    readonly size: _angular_core.InputSignal<"default" | "sm">;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HlmSelectTrigger, "hlm-select-trigger", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["_icon"], ["*", "ng-icon"], true, never>;
+}
+
+declare class HlmSelectValue {
+    readonly userClass: _angular_core.InputSignal<ClassValue>;
+    protected readonly _computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HlmSelectValue, "hlm-select-value,[hlmSelectValue], brn-select-value[hlm]", never, { "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HlmSelectImports: readonly [typeof HlmSelectContent, typeof HlmSelectTrigger, typeof HlmSelectOption, typeof HlmSelectValue, typeof HlmSelect, typeof HlmSelectScrollUp, typeof HlmSelectScrollDown, typeof HlmSelectLabel, typeof HlmSelectGroup];
+declare class HlmSelectModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HlmSelectModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<HlmSelectModule, never, [typeof HlmSelectContent, typeof HlmSelectTrigger, typeof HlmSelectOption, typeof HlmSelectValue, typeof HlmSelect, typeof HlmSelectScrollUp, typeof HlmSelectScrollDown, typeof HlmSelectLabel, typeof HlmSelectGroup], [typeof HlmSelectContent, typeof HlmSelectTrigger, typeof HlmSelectOption, typeof HlmSelectValue, typeof HlmSelect, typeof HlmSelectScrollUp, typeof HlmSelectScrollDown, typeof HlmSelectLabel, typeof HlmSelectGroup]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<HlmSelectModule>;
+}
+
+interface SelectOptions {
+    label: string;
+    value: unknown;
+}
+
+declare class SelectComponent {
+    placeholder: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<string>;
+    options: _angular_core.InputSignal<SelectOptions[]>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    defaultValue: _angular_core.InputSignal<SelectOptions | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<unknown>;
+    protected get variantClasses(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "sdc-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { HlmSelect, HlmSelectContent, HlmSelectGroup, HlmSelectImports, HlmSelectLabel, HlmSelectModule, HlmSelectOption, HlmSelectScrollDown, HlmSelectScrollUp, HlmSelectTrigger, HlmSelectValue, SelectComponent, selectTriggerVariants };
+export type { SelectOptions };

package/dist/types/3ddv-software-division-components-shared.d.ts

@@ -0,0 +1,69 @@
+import * as i0 from '@angular/core';
+import { ApplicationRef, PipeTransform, Provider, InjectionToken, Signal } from '@angular/core';
+
+/** * Declares CSS variables globally based on the 'theme' and 'dvmStyles' property of the configuration. */
+declare function applyGlobalCssVariables(appRef: ApplicationRef, theme: Record<string, string>): void;
+
+declare class FormatValuePipe implements PipeTransform {
+    private currencyPipe;
+    private datePipe;
+    transform(value: string, pipe: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatValuePipe, "formatValue", true>;
+}
+
+declare const SIZES: {
+    readonly xxs: "xxs";
+    readonly xs: "xs";
+    readonly sm: "sm";
+    readonly md: "md";
+    readonly lg: "lg";
+    readonly xl: "xl";
+    readonly '2xl': "2xl";
+};
+type Size = (typeof SIZES)[keyof typeof SIZES];
+/** Ordered array for size comparison logic */
+declare const SIZE_ORDER: Size[];
+type NgPipes = 'none' | 'currency' | 'date';
+type NgSdComponentsConfigValues = 'generic' | 'backoffice' | 'sdc';
+interface NgSdComponentsConfig {
+    theme: NgSdComponentsConfigValues;
+}
+type Theme = 'backoffice' | 'sdc';
+type ThemeClass = `theme-${Theme}`;
+
+/**
+ * Provides all necessary dependencies for the library:
+ * - Angular Pipes (`DatePipe`, `CurrencyPipe`)
+ * - Animations
+ * - CommonModule
+ */
+declare function provideSdc(config?: NgSdComponentsConfig): Provider[];
+
+declare const SCREENS_TOKEN: InjectionToken<Record<Size, string>>;
+declare function provideScreenObserver(screens: Record<Size, string>): Provider[];
+
+declare class ScreenObserver {
+    private readonly _size;
+    private readonly breakpoints;
+    readonly size: Signal<Size>;
+    readonly index: Signal<number>;
+    constructor(screens: Record<Partial<Size>, string>);
+    getSize(): Size;
+    isBiggerThan(screen: Size): boolean;
+    isSmallerThan(screen: Size): boolean;
+    isBiggerThan$(screen: Size): boolean;
+    isSmallerThan$(screen: Size): boolean;
+}
+
+declare class ThemeProviderDirective {
+    private configuration;
+    class: string;
+    theme: string;
+    constructor(configuration: NgSdComponentsConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeProviderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeProviderDirective, "[themeProvider]", never, {}, {}, never, never, true, never>;
+}
+
+export { FormatValuePipe, SCREENS_TOKEN, SIZES, SIZE_ORDER, ScreenObserver, ThemeProviderDirective, applyGlobalCssVariables, provideScreenObserver, provideSdc };
+export type { NgPipes, NgSdComponentsConfig, NgSdComponentsConfigValues, Size, ThemeClass };

package/dist/types/3ddv-software-division-components-utils.d.ts

@@ -0,0 +1,3 @@
+declare function validateStylesForComponent<T extends Record<string, string> | string>(componentName: string): (styles: T) => T;
+
+export { validateStylesForComponent };

package/dist/types/3ddv-software-division-components.d.ts

@@ -0,0 +1,2 @@
+export * from '@3ddv/software-division-components/shared';
+export { SCREENS_TOKEN, ScreenObserver, applyGlobalCssVariables, provideScreenObserver, provideSdc } from '@3ddv/software-division-components/shared';