@danske/sapphire-angular 1.12.4

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

@@ -0,0 +1,32 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SapphirePaginationChange {
+    /** The new page index */
+    readonly page: number;
+    /** The new page size */
+    readonly pageSize: number;
+    constructor(
+    /** The new page index */
+    page: number, 
+    /** The new page size */
+    pageSize: number);
+}
+export declare class PaginationComponent {
+    pageSize: number;
+    itemCount: number;
+    page: number;
+    pageSizeOptions?: number[];
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    get startItemIndex(): number;
+    get endItemIndex(): number;
+    readonly valueChange: EventEmitter<SapphirePaginationChange>;
+    _onPageSizeChange(value: string): void;
+    _onPageChange(direction: 'previous' | 'next'): void;
+    _isNextPageButtonDisabled(): boolean;
+    _isPreviousPageButtonDisabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "sp-pagination", never, { "pageSize": "pageSize"; "itemCount": "itemCount"; "page": "page"; "pageSizeOptions": "pageSizeOptions"; "disabled": "disabled"; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./pagination.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/cdk/a11y";
+import * as i4 from "../../select/src/select/select.module";
+import * as i5 from "../../button/src/button.module";
+import * as i6 from "../../icon/src/icon.module";
+export declare class SapphirePaginationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphirePaginationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphirePaginationModule, [typeof i1.PaginationComponent], [typeof i2.CommonModule, typeof i3.A11yModule, typeof i4.SapphireSelectModule, typeof i5.SapphireButtonModule, typeof i6.SapphireIconModule], [typeof i1.PaginationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphirePaginationModule>;
+}

package/lib/popover/public_api.d.ts

@@ -0,0 +1,5 @@
+export * from './src/popover.component';
+export * from './src/popover-title.directive';
+export * from './src/popover-close-button.directive';
+export * from './src/popover-trigger.directive';
+export * from './src/popover.module';

package/lib/popover/src/popover-close-button.directive.d.ts

@@ -0,0 +1,13 @@
+import { PopoverTrigger } from './popover-trigger.directive';
+import * as i0 from "@angular/core";
+/**
+ * Directive to be added to buttons inside popover, if they should close the popover
+ * when pressed.
+ */
+export declare class PopoverCloseButtonDirective {
+    private trigger?;
+    constructor(trigger?: PopoverTrigger | undefined);
+    private handleClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverCloseButtonDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverCloseButtonDirective, "button[spPopoverCloseButton]", never, {}, {}, never, never, false, never>;
+}

package/lib/popover/src/popover-title.directive.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+/**
+ * Directive to be added to the title of the popover. It will make sure the
+ * right accessibility attributes are set to have assistive technology
+ * describe the dialog by this title.
+ */
+export declare class PopoverTitleDirective {
+    ID: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverTitleDirective, "[spPopoverTitle]", never, {}, {}, never, never, false, never>;
+}

package/lib/popover/src/popover-trigger.directive.d.ts

@@ -0,0 +1,86 @@
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Placement } from '../../common/placement';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export interface PopoverTrigger {
+    toggle(): void;
+    open(): void;
+    close(): void;
+    elementRef: ElementRef<HTMLElement>;
+}
+export declare const POPOVER_TRIGGER: InjectionToken<PopoverTrigger>;
+export declare class PopoverTriggerDirective implements PopoverTrigger {
+    private changeDetectorRef;
+    private cdkOverlay;
+    private viewContainerRef;
+    elementRef: ElementRef<HTMLElement>;
+    private injector;
+    placement: Placement;
+    templateRef: TemplateRef<unknown> | null;
+    /**
+     * Whether the popover should not block interaction with background.
+     */
+    nonModal: BooleanInput;
+    /**
+     * Whether the popover should be opened on press start.
+     */
+    openOnPressStart: BooleanInput;
+    /**
+     * Whether the popover should be closed when the container is scrolled.
+     * @default false
+     */
+    closeOnScroll: BooleanInput;
+    /**
+     * Can be used to disable toggling popover on clicks. Useful if `spPopoverTrigger`
+     * is applied on an element which doesn't support `disabled` property.
+     */
+    disabled: BooleanInput;
+    /** Emits when the attached popover is requested to open */
+    readonly opened: EventEmitter<void>;
+    /** Emits when the attached popover is requested to close */
+    readonly closed: EventEmitter<void>;
+    /** Emits when this trigger is destroyed. */
+    protected readonly destroyed: Subject<void>;
+    /** A reference to the overlay which manages the triggered menu */
+    protected overlayRef: OverlayRef | null;
+    private isBeingPressed;
+    get getPopoverId(): string | undefined;
+    constructor(changeDetectorRef: ChangeDetectorRef, cdkOverlay: Overlay, viewContainerRef: ViewContainerRef, elementRef: ElementRef<HTMLElement>, injector: Injector);
+    ngOnDestroy(): void;
+    /** Toggle the attached popover. */
+    toggle(): void;
+    /** Open the attached popover. */
+    open(): void;
+    /** Close the opened popover. */
+    close(): void;
+    /** Whether the popover is open. */
+    isOpen(): boolean;
+    private handleMousedown;
+    private handleClick;
+    /**
+     * While onFocusout takes care of closing the popover when focus goes out, in the rare cases
+     * that there is no more focusable element between the trigger and the popover, the focus can
+     * go to the popover on pressing `Tab`. But the popover should be closed when tabbing on the
+     * trigger.
+     */
+    private handleTab;
+    /**
+     * In some use cases (e.g. in searchable select) popover trigger grabs the focus, right after
+     * the popover is opened. That requires popover trigger to detect when focus goes out of it
+     * and close the popover.
+     * Note: we can't use `blur` event since it won't bubble up, and the focus can be on an element
+     * inside the trigger, but not the trigger itself.
+     *
+     */
+    private onFocusout;
+    private handleKeyDown;
+    private destroyOverlay;
+    /** Get the configuration object used to create the overlay. */
+    private getOverlayConfig;
+    private getContentPortal;
+    private getOverlayPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverTriggerDirective, "[spPopoverTriggerFor]", ["spPopoverTrigger"], { "placement": "spPopoverPlacement"; "templateRef": "spPopoverTriggerFor"; "nonModal": "spPopoverNonModal"; "openOnPressStart": "spPopoverTriggerOpenOnPressStart"; "closeOnScroll": "spPopoverTriggerCloseOnScroll"; "disabled": "spPopoverTriggerDisabled"; }, { "opened": "spPopoverTriggerOpened"; "closed": "spPopoverTriggerClosed"; }, never, never, false, never>;
+}

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

@@ -0,0 +1,32 @@
+import { AfterViewInit } from '@angular/core';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { PopoverTrigger } from './popover-trigger.directive';
+import { PopoverTitleDirective } from './popover-title.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+import * as i2 from "../../common/sapphire-view-encapsulation";
+/**
+ * A generic popover component which lets you render arbitrary
+ * content in a popover overlay which is linked to a trigger, and is accessible
+ * as
+ * [dialog](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/dialog_role).
+ */
+export declare class PopoverComponent implements AfterViewInit {
+    private trigger?;
+    noPadding: BooleanInput;
+    noMaxWidth: BooleanInput;
+    title?: PopoverTitleDirective;
+    private contentWrapper?;
+    ID: string;
+    /**
+     * Keeps track of if the content is focused
+     */
+    private contentFocused;
+    constructor(trigger?: PopoverTrigger | undefined);
+    ngAfterViewInit(): void;
+    private handleEscape;
+    _contentFocusChanged(origin: FocusOrigin): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "sp-popover", never, { "noPadding": "noPadding"; "noMaxWidth": "noMaxWidth"; }, {}, ["title"], ["*"], false, [{ directive: typeof i1.ThemeCheckDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./popover.component";
+import * as i2 from "./popover-trigger.directive";
+import * as i3 from "./popover-close-button.directive";
+import * as i4 from "./popover-title.directive";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/cdk/a11y";
+export declare class SapphirePopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphirePopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphirePopoverModule, [typeof i1.PopoverComponent, typeof i2.PopoverTriggerDirective, typeof i3.PopoverCloseButtonDirective, typeof i4.PopoverTitleDirective], [typeof i5.CommonModule, typeof i6.A11yModule], [typeof i1.PopoverComponent, typeof i2.PopoverTriggerDirective, typeof i3.PopoverCloseButtonDirective, typeof i4.PopoverTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphirePopoverModule>;
+}

package/lib/radio/public_api.d.ts

@@ -0,0 +1,3 @@
+export * from './src/radio.component';
+export * from './src/radio-group.component';
+export * from './src/radio.module';

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

@@ -0,0 +1,65 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { RadioComponent, SapphireRadioChange } from './radio.component';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { FieldControl } from '../../field/src/field-control';
+import { FieldComponent } from '../../field/src/field.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+export declare class RadioGroupComponent implements ControlValueAccessor, FieldControl {
+    private changeDetectorRef;
+    _field: FieldComponent;
+    uniqueId: string;
+    orientation: 'vertical' | 'horizontal';
+    /** Name of the radio button group. All radio buttons inside this group will use this name. */
+    get name(): string;
+    set name(value: string);
+    private _name;
+    /**
+     * Event emitted when the group value changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * the radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: EventEmitter<SapphireRadioChange>;
+    get value(): any;
+    set value(newValue: any);
+    private _value;
+    /**
+     * The currently selected radio button. If set to a new radio button, the radio group value
+     * will be updated to match the new selected button. */
+    get selected(): RadioComponent | null;
+    set selected(selected: RadioComponent | null);
+    private _selected;
+    /** Whether the radio group is disabled */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    /** Whether the radio group is readonly */
+    get readonly(): boolean;
+    set readonly(value: BooleanInput);
+    private _readonly;
+    /** Whether the radio group is required */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    /** Child radio buttons. */
+    private radios;
+    private onTouched;
+    _controlValueAccessorChangeFn: (value: any) => void;
+    constructor(changeDetectorRef: ChangeDetectorRef, _field: FieldComponent);
+    _checkSelectedRadioButton(): void;
+    /** Dispatch change event with current selection and group value. */
+    _emitChangeEvent(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(disabled: boolean): void;
+    isDisabled(): boolean;
+    _contentFocusChanged(focusOrigin: FocusOrigin): void;
+    /** Updates the `selected` radio button from the internal _value state. */
+    private updateSelectedRadioFromValue;
+    private updateRadioButtonNames;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "sp-radio-group", never, { "orientation": "orientation"; "name": "name"; "value": "value"; "selected": "selected"; "disabled": "disabled"; "readonly": "readonly"; "required": "required"; }, { "change": "change"; }, ["radios"], ["*"], false, [{ directive: typeof i1.ThemeCheckDirective; inputs: {}; outputs: {}; }]>;
+}

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

@@ -0,0 +1,99 @@
+import { AfterViewInit, DoCheck, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CanDisable } from '../../common/disabled';
+import { HasTabIndex } from '../../common/tabindex';
+import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
+import { RadioGroupComponent } from './radio-group.component';
+import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+/** Change event object emitted by radio. */
+export declare class SapphireRadioChange {
+    /** The new `checked` value of the radio. */
+    readonly source: RadioComponent;
+    /** The source radio of the event. */
+    readonly value: any;
+    constructor(
+    /** The new `checked` value of the radio. */
+    source: RadioComponent, 
+    /** The source radio of the event. */
+    value: any);
+}
+declare const _RadioMixinBase: 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 RadioComponent extends _RadioMixinBase implements OnInit, AfterViewInit, DoCheck, OnDestroy, CanDisable, HasTabIndex {
+    readonly radioGroup: RadioGroupComponent;
+    private _focusMonitor;
+    private _radioDispatcher;
+    /**
+     * 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;
+    /** Analog to HTML 'name' attribute used to group radios for unique selection. */
+    name: string;
+    /** Analog to HTML 'name' attribute used to group radios for unique selection. */
+    autofocus: boolean;
+    _getAriaChecked(): 'true' | 'false';
+    /** A unique id for the radio input. If none is supplied, it will be auto-generated. */
+    id: string;
+    /** Returns the unique id for the visual hidden input. */
+    get inputId(): string;
+    /** Previous value of the input's tabindex. */
+    private previousTabIndex;
+    /** Unregister function for _radioDispatcher */
+    private removeUniqueSelectionListener;
+    /** The native `<input type="radio">` element */
+    _inputElement: ElementRef<HTMLInputElement>;
+    /** The value of this radio button. */
+    get value(): any;
+    set value(value: any);
+    private _value;
+    /** Whether this radio button is checked. */
+    get checked(): boolean;
+    set checked(value: BooleanInput);
+    private _checked;
+    /** Whether the radio button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    /** Whether the radio button is readonly. */
+    get readonly(): boolean;
+    set readonly(value: BooleanInput);
+    private _readonly;
+    /** Whether the radio button is required. */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    /**
+     * Event emitted when the checked state of this radio button changes.
+     * Change events are only emitted when the value changes due to user interaction with
+     * the radio button (the same behavior as `<input type-"radio">`).
+     */
+    readonly change: EventEmitter<SapphireRadioChange>;
+    constructor(radioGroup: RadioGroupComponent, elementRef: ElementRef, tabIndex: string, _focusMonitor: FocusMonitor, _radioDispatcher: UniqueSelectionDispatcher);
+    ngDoCheck(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Focuses the radio button. */
+    focus(options?: FocusOptions, origin?: FocusOrigin): void;
+    /** Gets the tabindex for the underlying input element. */
+    private updateTabIndex;
+    private emitChangeEvent;
+    /** Triggered when the radio button receives an interaction from the user. */
+    _onInputInteraction(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioComponent, [{ optional: true; }, null, { attribute: "tabindex"; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioComponent, "sp-radio", never, { "tabIndex": "tabIndex"; "ariaLabel": "aria-label"; "ariaLabelledby": "aria-labelledby"; "ariaDescribedby": "aria-describedby"; "name": "name"; "autofocus": "autofocus"; "id": "id"; "value": "value"; "checked": "checked"; "disabled": "disabled"; "readonly": "readonly"; "required": "required"; }, { "change": "change"; }, never, ["*"], false, [{ directive: typeof i1.ThemeCheckDirective; inputs: {}; outputs: {}; }]>;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./radio.component";
+import * as i2 from "./radio-group.component";
+import * as i3 from "@angular/common";
+import * as i4 from "../../label/src/label.component";
+import * as i5 from "@angular/cdk/a11y";
+import * as i6 from "../../field/src/field.module";
+export declare class SapphireRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireRadioModule, [typeof i1.RadioComponent, typeof i2.RadioGroupComponent], [typeof i3.CommonModule, typeof i4.LabelComponent, typeof i5.A11yModule, typeof i6.SapphireFieldModule], [typeof i1.RadioComponent, typeof i2.RadioGroupComponent, typeof i6.SapphireFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireRadioModule>;
+}

package/lib/segmented-tabs/public_api.d.ts

@@ -0,0 +1,5 @@
+export * from './src/segmented-tabs.module';
+export * from './src/segmented-tab.component';
+export * from './src/segmented-tabs.component';
+export * from './src/segmented-tab-label.directive';
+export * from './src/segmented-tab-content.directive';

package/lib/segmented-tabs/src/segmented-tab-content.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class SegmentedTabContentDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedTabContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedTabContentDirective, "sp-segmented-tab-content", never, {}, {}, never, never, false, never>;
+}

package/lib/segmented-tabs/src/segmented-tab-label.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class SegmentedTabLabelDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedTabLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SegmentedTabLabelDirective, "sp-segmented-tab-label", never, {}, {}, never, never, false, never>;
+}

package/lib/segmented-tabs/src/segmented-tab.component.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef, TemplateRef } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { SegmentedTabsComponent } from './segmented-tabs.component';
+import * as i0 from "@angular/core";
+export declare class SegmentedTabComponent {
+    tabs: SegmentedTabsComponent;
+    /** Whether the tab should be disabled */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    label?: string;
+    /**
+     * auto generated id applied on the tab element
+     */
+    id: string;
+    _contentTemplate: TemplateRef<any> | null;
+    _button?: ElementRef<HTMLButtonElement>;
+    constructor(tabs: SegmentedTabsComponent);
+    select(): void;
+    /**
+     * Whether this tab is currently selected
+     */
+    isSelected(): boolean;
+    getTabIndex(): "0" | "-1";
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedTabComponent, "sp-segmented-tab", never, { "disabled": "disabled"; "label": "label"; }, {}, never, ["sp-segmented-tab-label", "sp-segmented-tab-content"], false, never>;
+}

package/lib/segmented-tabs/src/segmented-tabs.component.d.ts

@@ -0,0 +1,48 @@
+import { AfterContentInit, AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { SegmentedTabComponent } from './segmented-tab.component';
+import * as i0 from "@angular/core";
+export declare class SegmentedTabsComponent implements AfterContentInit, AfterViewInit, OnInit, OnDestroy {
+    private host;
+    private zone;
+    private changeDetector;
+    /** Size of tabs */
+    size: 'small' | 'medium' | 'large';
+    /** Whether tabs are activated automatically on focus or manually. */
+    keyboardActivation?: 'manual' | 'automatic';
+    /** Whether the entire component should be disabled */
+    disabled: BooleanInput;
+    /** Index of the selected tab */
+    get selectedIndex(): number;
+    set selectedIndex(value: NumberInput);
+    private _selectedIndex?;
+    private _focusedIndex;
+    readonly selectedIndexChange: EventEmitter<number>;
+    readonly tabs: QueryList<SegmentedTabComponent>;
+    private _tabIds;
+    private resizeObserver;
+    _activeTabPosition: {
+        left: string;
+        width: string;
+    };
+    _animationEnabled: boolean;
+    _focusVisible: boolean;
+    constructor(host: ElementRef, zone: NgZone, changeDetector: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    getFocusedTab(): SegmentedTabComponent;
+    selectTab(selectedTab: SegmentedTabComponent): void;
+    isSelected(tab: SegmentedTabComponent): boolean;
+    _getTabContentTemplate(): import("@angular/core").TemplateRef<any> | null;
+    _onFocusChange(origin: FocusOrigin): void;
+    _onKeyDown(event: KeyboardEvent): void;
+    private setActiveTabPosition;
+    private onTabsChange;
+    private skipAnimationFrame;
+    private findFocusableIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentedTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentedTabsComponent, "sp-segmented-tabs", ["spSegmentedTabs"], { "size": "size"; "keyboardActivation": "keyboardActivation"; "disabled": "disabled"; "selectedIndex": "selectedIndex"; }, { "selectedIndexChange": "selectedIndexChange"; }, ["tabs"], ["sp-segmented-tab"], false, never>;
+}

package/lib/segmented-tabs/src/segmented-tabs.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./segmented-tabs.component";
+import * as i2 from "./segmented-tab.component";
+import * as i3 from "./segmented-tab-label.directive";
+import * as i4 from "./segmented-tab-content.directive";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/cdk/a11y";
+import * as i7 from "../../common/sapphire-view-encapsulation";
+export declare class SapphireSegmentedTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireSegmentedTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireSegmentedTabsModule, [typeof i1.SegmentedTabsComponent, typeof i2.SegmentedTabComponent, typeof i3.SegmentedTabLabelDirective, typeof i4.SegmentedTabContentDirective], [typeof i5.CommonModule, typeof i6.A11yModule, typeof i7.UseComponentStyles], [typeof i1.SegmentedTabsComponent, typeof i2.SegmentedTabComponent, typeof i3.SegmentedTabLabelDirective, typeof i4.SegmentedTabContentDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireSegmentedTabsModule>;
+}

package/lib/select/public_api.d.ts

@@ -0,0 +1,5 @@
+export { SelectComponent, MultiSelectDirective, SingleSelectDirective, } from './src/select/select.component';
+export { SapphireSelectModule } from './src/select/select.module';
+export { SelectionTextDirective } from './src/select/selection-text.directive';
+export { SearchableSelectDirective } from './src/select/searchable-select.directive';
+export { BasicSelectComponent, BasicSingleSelectDirective, } from './src/basic-select/basic-select.component';

package/lib/select/src/basic-select/basic-select.component.d.ts

@@ -0,0 +1,50 @@
+import { ElementRef } from '@angular/core';
+import { PopoverTriggerDirective } from '../../../popover/src/popover-trigger.directive';
+import { ListboxComponent } from '../../../listbox/src/listbox.component';
+import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
+import { SelectComponentBase } from '../common/select-component-base';
+import { SelectValueHolder, SingleSelectDirectiveBase } from '../common/select-value-holder';
+import * as i0 from "@angular/core";
+/**
+ * NOTE: Support for multiple selection in basic select is removed, based on
+ * a UX decision. See commit message for more details.
+ */
+export declare class BasicSingleSelectDirective extends SingleSelectDirectiveBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasicSingleSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BasicSingleSelectDirective, "sp-basic-select:not([multiple])", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Allows user to select a single option from a list, similar to native select
+ * component.
+ *
+ * Example:
+ * ```tsx
+ * <sp-basic-select
+ *    placeholder="Select an option"
+ *    size="small"
+ *    variant="contained"
+ * >
+ *   <sp-option value="option1">First Option</sp-option>
+ *   <sp-option value="option2">Second Option</sp-option>
+ *   <sp-option value="option3">Third Option</sp-option>
+ * </sp-basic-select>
+ * ```
+ */
+export declare class BasicSelectComponent extends SelectComponentBase {
+    private focusMonitor;
+    /**
+     * Size of the button
+     */
+    size: 'small' | 'medium' | 'large';
+    variant: 'primary' | 'contained' | 'uncontained';
+    protected triggerRef: PopoverTriggerDirective | undefined;
+    protected triggerElementRef: ElementRef | undefined;
+    protected listbox: ListboxComponent | undefined;
+    private focused;
+    constructor(valueHolder: SelectValueHolder, focusMonitor: FocusMonitor);
+    focus(focusOrigin?: FocusOrigin): void;
+    isFocused(): boolean;
+    _onFocusChange(focusOrigin: FocusOrigin): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasicSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BasicSelectComponent, "sp-basic-select", ["spBasicSelect"], { "size": "size"; "variant": "variant"; }, {}, never, ["sp-selection-text"], false, never>;
+}

package/lib/select/src/common/hidden-select.component.d.ts

@@ -0,0 +1,19 @@
+import { SelectComponentBase } from './select-component-base';
+import * as i0 from "@angular/core";
+/**
+ * Hidden native select to be rendered in sapphire select components. It does two things:
+ * - Takes care of form accessibility and autofilling by rendering native select/input
+ * - Opens the native select dropdown instead of the custom dropdown, when possible.
+ *
+ * The latter proved to be a questionable, and we may rethink it at some point.
+ *
+ * @internal
+ */
+export declare class HiddenSelectComponent {
+    _select: SelectComponentBase;
+    _isMobile: any;
+    constructor(_select: SelectComponentBase);
+    _onNativeSelectChange(e: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HiddenSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HiddenSelectComponent, "sp-hidden-select", never, {}, {}, never, never, false, never>;
+}