@danske/sapphire-angular 1.12.4

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@danske/sapphire-angular" />
+export * from './public-api';

package/lib/badge/public_api.d.ts

@@ -0,0 +1,2 @@
+export { BadgeComponent } from './src/badge.component';
+export { SapphireBadgeModule } from './src/badge.module';

package/lib/badge/src/badge.component.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/sapphire-view-encapsulation";
+type Color = 'positive' | 'negative' | 'warning' | 'informative' | 'passive' | 'aqua' | 'copper' | 'electro' | 'indigo' | 'lime' | 'pink' | 'violet' | 'gold' | 'beige' | 'orchid' | 'gray' | 'cobalt' | 'forestGreen' | 'teal' | 'orange';
+type Variant = 'primary' | 'secondary';
+type Size = 'small' | 'medium' | 'large';
+export declare class BadgeComponent {
+    role: string;
+    /**
+     * A unique id for the host DOM element.
+     * If none is supplied, it will be auto-generated.
+     */
+    id: string;
+    /**
+     * @default 'medium'
+     */
+    size?: Size;
+    /**
+     * Whether the badge has a saturated or faint background.
+     *
+     * @default 'primary'
+     */
+    variant?: Variant;
+    /**
+     * The background color of the badge.
+     * Can either be semantic or one of the named decorative color.
+     *
+     * @default 'informative'
+     */
+    color?: Color;
+    private get classNames();
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "sp-badge", never, { "id": "id"; "size": "size"; "variant": "variant"; "color": "color"; }, {}, never, ["*"], false, [{ directive: typeof i1.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}
+export {};

package/lib/badge/src/badge.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./badge.component";
+import * as i2 from "@angular/common";
+export declare class SapphireBadgeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireBadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireBadgeModule, [typeof i1.BadgeComponent], [typeof i2.CommonModule], [typeof i1.BadgeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireBadgeModule>;
+}

package/lib/button/public_api.d.ts

@@ -0,0 +1,7 @@
+export * from './src/button-group.component';
+export * from './src/button.component';
+export * from './src/icon-button.component';
+export * from './src/toggle-button.component';
+export * from './src/toggle-button-required-validator';
+export * from './src/button-icon.directive';
+export * from './src/button.module';

package/lib/button/src/button-group.component.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from "@angular/core";
+/**
+ * ButtonGroup is a utility component which ensures consistent spacing between
+ * buttons All children must be of type Button. Icon buttons cannot be mixed
+ * with standard buttons.
+ */
+export declare class ButtonGroupComponent {
+    /**
+     * Alignment of buttons within the group.
+     * @default "right"
+     */
+    align: 'left' | 'center' | 'right';
+    get iconSpacing(): this['spacing'];
+    set iconSpacing(value: this['spacing']);
+    /**
+     * Spacing between the buttons
+     * @default normal
+     */
+    spacing: 'normal' | 'dense' | 'large';
+    /**
+     * @default "horizontal"
+     */
+    orientation?: 'vertical' | 'horizontal';
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonGroupComponent, "sp-button-group", never, { "align": "align"; "iconSpacing": "iconSpacing"; "spacing": "spacing"; "orientation": "orientation"; }, {}, never, ["*"], false, never>;
+}

package/lib/button/src/button-icon.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ButtonIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonIconDirective, "[spButtonIcon]", never, {}, {}, never, never, false, never>;
+}

package/lib/button/src/button.component.d.ts

@@ -0,0 +1,31 @@
+import { AfterContentInit, ElementRef } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { IconComponent } from '../../icon/public_api';
+import { ButtonIconDirective } from './button-icon.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+import * as i2 from "../../common/sapphire-view-encapsulation";
+export declare class ButtonComponent implements AfterContentInit {
+    elementRef: ElementRef<HTMLButtonElement>;
+    variant?: 'primary' | 'secondary' | 'tertiary' | 'danger' | 'dangerSecondary' | 'dangerTertiary';
+    appearance?: 'fill' | 'ghost' | 'text';
+    /**
+     * Applies different styles for a better contrast with the secondary color background.
+     * @default 'primary'
+     */
+    surface?: 'primary' | 'secondary';
+    size?: 'small' | 'medium' | 'large';
+    disabled: BooleanInput;
+    iconAlign: 'left' | 'right';
+    /**
+     * The behavior of the button when used in an HTML form.
+     */
+    type: 'submit' | 'button' | 'reset';
+    private get derivedVariantAndStyleClass();
+    buttonIcon?: ButtonIconDirective;
+    icon?: IconComponent;
+    constructor(elementRef: ElementRef<HTMLButtonElement>);
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "button[sp-button], a[sp-button]", never, { "variant": "variant"; "appearance": "appearance"; "surface": "surface"; "size": "size"; "disabled": "disabled"; "iconAlign": "iconAlign"; "type": "type"; }, {}, ["buttonIcon", "icon"], ["*", "[spButtonIcon]"], false, [{ directive: typeof i1.ThemeCheckDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}

package/lib/button/src/button.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./button.component";
+import * as i2 from "./button-icon.directive";
+import * as i3 from "./icon-button.component";
+import * as i4 from "./toggle-button.component";
+import * as i5 from "./button-group.component";
+import * as i6 from "./toggle-button-required-validator";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/forms";
+export declare class SapphireButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireButtonModule, [typeof i1.ButtonComponent, typeof i2.ButtonIconDirective, typeof i3.IconButtonComponent, typeof i4.ToggleButtonComponent, typeof i5.ButtonGroupComponent, typeof i6.SapphireToggleButtonRequiredValidator], [typeof i7.CommonModule, typeof i8.FormsModule], [typeof i1.ButtonComponent, typeof i2.ButtonIconDirective, typeof i3.IconButtonComponent, typeof i4.ToggleButtonComponent, typeof i5.ButtonGroupComponent, typeof i6.SapphireToggleButtonRequiredValidator]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireButtonModule>;
+}

package/lib/button/src/icon-button.component.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, AfterViewInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { IconSizeProvider } from '../../icon/src/icon-size-provider';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/sapphire-view-encapsulation";
+export declare class IconButtonComponent implements IconSizeProvider, AfterViewInit {
+    private elementRef;
+    variant?: 'primary' | 'secondary' | 'tertiary' | 'danger' | 'neutral';
+    appearance?: 'fill' | 'ghost';
+    /**
+     * Applies different styles for a better contrast with the secondary color background.
+     * @default 'primary'
+     */
+    surface?: 'primary' | 'secondary';
+    size?: 'extraSmall' | 'small' | 'medium' | 'large';
+    disabled: BooleanInput;
+    private get derivedVariantAndStyleClass();
+    /**
+     * The behavior of the button when used in an HTML form.
+     */
+    type: 'submit' | 'button' | 'reset';
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconButtonComponent, "button[sp-icon-button], a[sp-icon-button]", never, { "variant": "variant"; "appearance": "appearance"; "surface": "surface"; "size": "size"; "disabled": "disabled"; "type": "type"; }, {}, never, ["*"], false, [{ directive: typeof i1.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}

package/lib/button/src/toggle-button-required-validator.d.ts

@@ -0,0 +1,10 @@
+import { CheckboxRequiredValidator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Validator for Sapphire checkbox's isRequired attribute in template-driven checkbox.
+ */
+export declare class SapphireToggleButtonRequiredValidator extends CheckboxRequiredValidator {
+    required: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireToggleButtonRequiredValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SapphireToggleButtonRequiredValidator, "button[sp-toggle-button][required][formControlName],             button[sp-toggle-button][required][formControl],             button[sp-toggle-button][required][ngModel]", never, { "required": "required"; }, {}, never, never, false, never>;
+}

package/lib/button/src/toggle-button.component.d.ts

@@ -0,0 +1,39 @@
+import { AfterContentInit, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { IconComponent } from '../../icon/public_api';
+import { ButtonIconDirective } from './button-icon.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/sapphire-view-encapsulation";
+/**
+ * A button with a toggleable `isSelected` state. By default, the selection is
+ * toggled when the button is pressed, allowing user to switch between two
+ * states or modes.
+ */
+export declare class ToggleButtonComponent implements AfterContentInit, OnChanges, ControlValueAccessor {
+    size?: 'small' | 'medium' | 'large';
+    selected: BooleanInput;
+    /**
+     * Whether selected is controlled. If it's controlled via input binding,
+     * then we just output selectChanges, without updating this._selected.
+     */
+    private isSelectedControlled;
+    selectedChange: EventEmitter<boolean>;
+    disabled: BooleanInput;
+    iconAlign: 'left' | 'right';
+    buttonIcon?: ButtonIconDirective;
+    icon?: IconComponent;
+    private onTouched;
+    private controlValueAccessorChangeFn;
+    constructor();
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    _onBlur(): void;
+    private handleClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleButtonComponent, "button[sp-toggle-button]", never, { "size": "size"; "selected": "selected"; "disabled": "disabled"; "iconAlign": "iconAlign"; }, { "selectedChange": "selectedChange"; }, ["buttonIcon", "icon"], ["*", "[spButtonIcon]"], false, [{ directive: typeof i1.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}

package/lib/checkbox/public_api.d.ts

@@ -0,0 +1,3 @@
+export * from './src/checkbox.component';
+export * from './src/checkbox.module';
+export * from './src/checkbox-required-validator';

package/lib/checkbox/src/checkbox-required-validator.d.ts

@@ -0,0 +1,10 @@
+import { CheckboxRequiredValidator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Validator for Sapphire checkbox's "required" attribute in template-driven checkbox.
+ */
+export declare class SapphireCheckboxRequiredValidator extends CheckboxRequiredValidator {
+    required: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireCheckboxRequiredValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SapphireCheckboxRequiredValidator, "sp-checkbox[required][formControlName],             sp-checkbox[required][formControl], sp-checkbox[required][ngModel]", never, { "required": "required"; }, {}, never, never, false, never>;
+}

package/lib/checkbox/src/checkbox.component.d.ts

@@ -0,0 +1,112 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter } from '@angular/core';
+import { FocusableOption } from '@angular/cdk/a11y';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ControlValueAccessor } from '@angular/forms';
+import { HasTabIndex } from '../../common/tabindex';
+import { CanDisable } from '../../common/disabled';
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+/** Change event object emitted by checkbox. */
+export declare class CheckboxChange {
+    /** The new `selected` value of the checkbox. */
+    readonly selected: boolean;
+    /** The source checkbox of the event. */
+    readonly source: CheckboxComponent;
+    constructor(
+    /** The new `selected` value of the checkbox. */
+    selected: boolean, 
+    /** The source checkbox of the event. */
+    source: CheckboxComponent);
+}
+declare const _CheckboxMixinBase: import("../../common/constructor").Constructor<HasTabIndex> & import("../../common/constructor").AbstractConstructor<HasTabIndex> & import("../../common/constructor").Constructor<CanDisable> & import("../../common/constructor").AbstractConstructor<CanDisable> & {
+    new (_elementRef: ElementRef): {
+        _elementRef: ElementRef;
+    };
+};
+export declare class CheckboxComponent extends _CheckboxMixinBase implements AfterViewInit, ControlValueAccessor, CanDisable, HasTabIndex, FocusableOption {
+    private changeDetectorRef;
+    /**
+     * Attached to the aria-label attribute of the host element. In most cases,
+     * aria-labelledby will take precedence so this may be omitted.
+     */
+    ariaLabel: string;
+    /**
+     * Users can specify the `aria-labelledby` attribute which will be forwarded
+     * to the input element
+     */
+    ariaLabelledby: string | null;
+    /** The 'aria-describedby' attribute is read after the element's label and field type. */
+    ariaDescribedby: string;
+    /** A unique id for the checkbox input. If none is supplied, it will be auto-generated. */
+    id: string;
+    /** Returns the unique id for the visual hidden input. */
+    get _inputId(): string;
+    /** Whether the checkbox is required. */
+    required: BooleanInput;
+    /**
+     * Whether the checkbox is readonly.
+     */
+    readonly: BooleanInput;
+    /** Name value will be applied to the input element if present */
+    name: string | null;
+    size?: 'large' | 'medium';
+    /** Event emitted when the checkbox's `selected` value changes. */
+    readonly change: EventEmitter<CheckboxChange>;
+    /** The value attribute of the native input element */
+    value: string | undefined;
+    /** The native `<input type="checkbox">` element */
+    _inputElement: ElementRef<HTMLInputElement>;
+    /**
+     * Called when the checkbox is blurred. Needed to properly implement
+     * ControlValueAccessor.
+     * @docs-private
+     */
+    private onTouched;
+    private controlValueAccessorChangeFn;
+    constructor(elementRef: ElementRef<HTMLElement>, changeDetectorRef: ChangeDetectorRef, tabIndex: string);
+    ngAfterViewInit(): void;
+    /** Whether the checkbox is selected. */
+    get selected(): boolean;
+    set selected(value: BooleanInput);
+    private _selected;
+    /**
+     * Whether the checkbox is disabled. This fully overrides the implementation
+     * provided by mixinDisabled, but the mixin is still required because
+     * mixinTabIndex requires it.
+     */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    /**
+     * Whether the checkbox is indeterminate. This is also known as "mixed" mode
+     * and can be used to represent a checkbox with three states, e.g. a checkbox
+     * that represents a nested list of checkable items.
+     */
+    get indeterminate(): boolean;
+    set indeterminate(value: BooleanInput);
+    private _indeterminate;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(disabled: boolean): void;
+    /** Toggles the `selected` state of the checkbox. */
+    toggle(): void;
+    focus(): void;
+    _getAriaChecked(): 'true' | 'false' | 'mixed';
+    _onInputClick($event: Event): void;
+    _onInteractionEvent(event: Event): void;
+    _onBlur(): void;
+    private emitChangeEvent;
+    /**
+     * Syncs the indeterminate value with the checkbox DOM node.
+     *
+     * We sync `indeterminate` directly on the DOM node, because in Ivy the check
+     * for whether a property is supported on an element boils down to `if
+     * (propName in element)`. Domino's HTMLInputElement doesn't have an
+     * `indeterminate` property so Ivy will warn during server-side rendering.
+     */
+    private syncIndeterminate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, [null, null, { attribute: "tabindex"; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "sp-checkbox", ["spCheckbox"], { "ariaLabel": "aria-label"; "ariaLabelledby": "aria-labelledby"; "ariaDescribedby": "aria-describedby"; "id": "id"; "required": "required"; "readonly": "readonly"; "name": "name"; "size": "size"; "value": "value"; "selected": "selected"; "disabled": "disabled"; "indeterminate": "indeterminate"; }, { "change": "change"; }, never, ["*"], false, [{ directive: typeof i1.ThemeCheckDirective; inputs: {}; outputs: {}; }]>;
+}
+export {};

package/lib/checkbox/src/checkbox.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./checkbox.component";
+import * as i2 from "./checkbox-required-validator";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/cdk/a11y";
+export declare class SapphireCheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireCheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireCheckboxModule, [typeof i1.CheckboxComponent, typeof i2.SapphireCheckboxRequiredValidator], [typeof i3.CommonModule, typeof i4.FormsModule, typeof i5.A11yModule], [typeof i1.CheckboxComponent, typeof i2.SapphireCheckboxRequiredValidator]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireCheckboxModule>;
+}

package/lib/common/auto-id.decorator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * To be used on id props that require an auto-generated value, if none provided
+ * by the user.
+ */
+export declare const AutoId: ({ prefix }?: {
+    prefix?: string | undefined;
+}) => (clazz: any, propName: string, descriptor?: any) => any;

package/lib/common/coerce-boolean.decorator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * To be used on input props of type boolean, to allow value-less shorthand
+ * usage. A caveat is that the type will need to be BooleanInput, since TS
+ * doesn't support type mutations through decorators, at the moment:
+ * https://github.com/Microsoft/TypeScript/issues/4881
+ */
+export declare function CoerceBoolean(clazz: any, propName: string, descriptor?: any): any;

package/lib/common/constructor.d.ts

@@ -0,0 +1,2 @@
+export type Constructor<T> = new (...args: any[]) => T;
+export type AbstractConstructor<T = object> = abstract new (...args: any[]) => T;

package/lib/common/disabled.d.ts

@@ -0,0 +1,9 @@
+import { AbstractConstructor, Constructor } from './constructor';
+export interface CanDisable {
+    /** Whether the component is disabled. */
+    disabled: boolean;
+}
+type CanDisableConstructor = Constructor<CanDisable> & AbstractConstructor<CanDisable>;
+/** Mixin to augment a directive with a `disabled` property. */
+export declare function mixinDisabled<T extends AbstractConstructor<{}>>(base: T): CanDisableConstructor & T;
+export {};

package/lib/common/focused.directive.d.ts

@@ -0,0 +1,30 @@
+import { InputModalityDetector } from '@angular/cdk/a11y';
+import * as i0 from "@angular/core";
+/**
+ * JS-based :focus-visible state. Based on the convention in Sapphire styles, it:
+ * - adds js-focus class to the host element
+ * - adds is-focus class when `spFocused` is true, and focus should be visible.
+ * is-focus class can be customized via `spFocusedClass` input
+
+ */
+export declare class FocusedDirective {
+    private inputModalityDetector;
+    /**
+     * CSS class to be applied when the element is focused, and focus should be visible.
+     */
+    focusedClass: string;
+    /**
+     * Whether the element is (virtually) focused. If not provided, the actual focus
+     * state of the host element will be used to determine the focus state.
+     */
+    focusedInput?: boolean;
+    private hostFocused;
+    private get className();
+    private onFocusIn;
+    private onFocusOut;
+    isFocused(): boolean;
+    isFocusVisible(): boolean;
+    constructor(inputModalityDetector: InputModalityDetector);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusedDirective, "[spFocused]", ["spFocused"], { "focusedClass": "spFocusedClass"; "focusedInput": "spFocused"; }, {}, never, never, true, never>;
+}

package/lib/common/placement.d.ts

@@ -0,0 +1,11 @@
+import { ConnectedPosition } from '@angular/cdk/overlay';
+export type HorizontalPlacement = 'start' | 'end';
+export type VerticalPlacement = 'top' | 'bottom';
+export type Placement = HorizontalPlacement | VerticalPlacement | `${HorizontalPlacement} ${VerticalPlacement}` | `${VerticalPlacement} ${HorizontalPlacement}`;
+/**
+ * Converts our `Placement` input (which is aligned with react implementation), to Angular CDK
+ * `ConnectedPosition`
+ * @param placement
+ */
+export declare function toConnectedPosition(placement: Placement): ConnectedPosition;
+export declare function flip(placement: Placement): Placement;

package/lib/common/platform.d.ts

@@ -0,0 +1,9 @@
+export declare function isMac(): boolean;
+export declare function isIPhone(): boolean;
+export declare function isIPad(): boolean;
+export declare function isIOS(): boolean;
+export declare function isAppleDevice(): boolean;
+export declare function isWebKit(): any;
+export declare function isChrome(): any;
+export declare function isAndroid(): any;
+export declare function isMobile(): any;

package/lib/common/pressed.directive.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * JS-based :active state for non-button clickable elements.
+ * TODO(UC-2728): we can evolve this to something like usePress (spPressable?), to bring
+ *  the same improvements. e.g. disabling selection on press, or normalizing
+ *  cross-browser inconsistencies, allowing for handling press start and end, optimizing for touch,
+ *  etc.
+ */
+export declare class PressedDirective {
+    private document;
+    private elementRef;
+    /**
+     * CSS class to be applied when the element is being pressed.
+     */
+    pressedClass?: string;
+    /**
+     * Whether the element is currently in being pressed (:active) state
+     */
+    _pressed: boolean;
+    get pressed(): boolean;
+    set pressed(pressed: boolean);
+    _onPressStart(): void;
+    constructor(document: Document, elementRef: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PressedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PressedDirective, "[spPressed], [spPressedClass]", ["spPressed"], { "pressedClass": "spPressedClass"; }, {}, never, never, true, never>;
+}

package/lib/common/public_api.d.ts

@@ -0,0 +1,2 @@
+export { ScrollMonitorDirective } from './scroll-monitor.directive';
+export { UseComponentStyles, UseComponentStylesOnHost, ViewEncapsulationProvider, } from './sapphire-view-encapsulation';

package/lib/common/sapphire-view-encapsulation.d.ts

@@ -0,0 +1,37 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Captures the view encapsulation of the current component, and makes it possible to apply that
+ * on elements in the component's subtree, using {@link UseComponentStyles} directive.
+ * Useful when a component has subcomponents, but they are a single component in css-level.
+ */
+export declare class ViewEncapsulationProvider {
+    private elementRef;
+    private renderer;
+    constructor(elementRef: ElementRef<Element>, renderer: Renderer2);
+    enableStylesOn(element: Element): void;
+    private getContentAttribute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewEncapsulationProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewEncapsulationProvider>;
+}
+/**
+ * Enables the use of component's css classes on the host element. Also provides
+ * `ViewEncapsulationProvider` which allows for using `UseComponentStyles` in child components.
+ * Meant to be used internally, and in components in @danske/sapphire-angular-lab.
+ * @internal
+ */
+export declare class UseComponentStylesOnHost {
+    constructor(elementRef: ElementRef, viewEncapsulationProvider: ViewEncapsulationProvider);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UseComponentStylesOnHost, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UseComponentStylesOnHost, "[_spUseComponentStylesOnHost]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Enables the use of css classes from parent component's styles. Meant to be used internally,
+ * and in components in @danske/sapphire-angular-lab.
+ * @internal
+ */
+export declare class UseComponentStyles {
+    constructor(elementRef: ElementRef, viewEncapsulationProvider: ViewEncapsulationProvider);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UseComponentStyles, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UseComponentStyles, "[_spUseComponentStyles]", never, {}, {}, never, never, true, never>;
+}

package/lib/common/scroll-monitor.directive.d.ts

@@ -0,0 +1,23 @@
+import { ElementRef, EventEmitter, NgZone, OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Monitors host element's **scrolled** and **scrollable** state.
+ */
+export declare class ScrollMonitorDirective implements OnInit, OnDestroy {
+    private elementRef;
+    private ngZone;
+    scrolled: boolean;
+    scrollable: boolean;
+    change: EventEmitter<{
+        scrollable: boolean;
+        scrolled: boolean;
+    }>;
+    private resizeObserver?;
+    private subscription?;
+    constructor(elementRef: ElementRef, ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollMonitorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollMonitorDirective, "[spScrollMonitor]", ["spScrollMonitor"], {}, { "change": "spScrollMonitor"; }, never, never, true, never>;
+}

package/lib/common/tabindex.d.ts

@@ -0,0 +1,12 @@
+import { Constructor, AbstractConstructor } from './constructor';
+import { CanDisable } from './disabled';
+export interface HasTabIndex {
+    /** Tabindex of the component. */
+    tabIndex: number;
+    /** Tabindex to which to fall back to if no value is set. */
+    defaultTabIndex: number;
+}
+type HasTabIndexConstructor = Constructor<HasTabIndex> & AbstractConstructor<HasTabIndex>;
+/** Mixin to augment a directive with a `tabIndex` property. */
+export declare function mixinTabIndex<T extends AbstractConstructor<CanDisable>>(base: T, defaultTabIndex?: number): HasTabIndexConstructor & T;
+export {};

package/lib/common/visually-hidden.directive.d.ts

@@ -0,0 +1,11 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+/**
+ * Hides an element visually, while keeping it visible to screen readers and
+ * other assistive technology
+ */
+export declare class VisuallyHiddenDirective {
+    enabled: BooleanInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisuallyHiddenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VisuallyHiddenDirective, "[spVisuallyHidden]", never, { "enabled": "spVisuallyHidden"; }, {}, never, never, true, never>;
+}

package/lib/contextual-help/public_api.d.ts

@@ -0,0 +1,2 @@
+export { SapphireContextualHelpModule } from './src/contextual-help.module';
+export { ContextualHelpComponent, ContextualHelpFooterDirective, ContextualHelpHeaderDirective, ContextualHelpContentDirective, } from './src/contextual-help.component';

package/lib/contextual-help/src/contextual-help.component.d.ts

@@ -0,0 +1,50 @@
+import { PopoverTriggerDirective } from '../../popover/src/popover-trigger.directive';
+import { Placement } from '../../common/placement';
+import * as i0 from "@angular/core";
+export declare class ContextualHelpHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextualHelpHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextualHelpHeaderDirective, "sp-contextual-help-header", never, {}, {}, never, never, true, never>;
+}
+export declare class ContextualHelpContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextualHelpContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextualHelpContentDirective, "sp-contextual-help-content", never, {}, {}, never, never, true, never>;
+}
+export declare class ContextualHelpFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextualHelpFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextualHelpFooterDirective, "sp-contextual-help-footer", never, {}, {}, never, never, true, never>;
+}
+export declare class ContextualHelpComponent {
+    /**
+     *
+     * The type of contextual help which determines the icon shown.
+     *
+     * Use "info" for brief, contextual supplemental information. The content
+     * inside should have an instructive tone.
+     *
+     * Use "help" variant to signal more in-depth guidance about a task or UI,
+     * this may include links or images or other helpful media. The content
+     * inside should have a helpful tone.
+     *
+     * @default 'info'
+     */
+    variant: 'info' | 'help';
+    /**
+     * Placement of contextual help popover relative to the icon that triggers it.
+     */
+    placement: Placement;
+    /**
+     * The label for the trigger of the contextual help dialog.
+     * This will NOT be rendered on the screen, but it is required
+     * for accessibility reasons.
+     */
+    ariaLabel: string;
+    _trigger?: PopoverTriggerDirective;
+    _footer?: ContextualHelpFooterDirective;
+    _header?: ContextualHelpHeaderDirective;
+    isOpen(): boolean | undefined;
+    toggle(): void | undefined;
+    open(): void | undefined;
+    close(): void | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextualHelpComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextualHelpComponent, "sp-contextual-help", never, { "variant": "variant"; "placement": "placement"; "ariaLabel": "aria-label"; }, {}, ["_footer", "_header"], ["sp-contextual-help-header", "sp-contextual-help-content", "sp-contextual-help-footer"], true, never>;
+}